git.oblomov.eu Git - wine/blob - dlls/msi/msi.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2002,2003,2004,2005 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winreg.h"
  29 #include "winnls.h"
  30 #include "shlwapi.h"
  31 #include "wine/debug.h"
  32 #include "msi.h"
  33 #include "msidefs.h"
  34 #include "msiquery.h"
  35 #include "msipriv.h"
  36 #include "wincrypt.h"
  37 #include "winver.h"
  38 #include "winuser.h"
  39 #include "shlobj.h"
  40 #include "shobjidl.h"
  41 #include "objidl.h"
  42 #include "wine/unicode.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  45
  46 static const WCHAR installerW[] = {'\\','I','n','s','t','a','l','l','e','r',0};
  47
  48 static UINT msi_locate_product(LPCWSTR szProduct, MSIINSTALLCONTEXT *context)
  49 {
  50     HKEY hkey = NULL;
  51
  52     *context = MSIINSTALLCONTEXT_NONE;
  53
  54     if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
  55                               &hkey, FALSE) == ERROR_SUCCESS)
  56         *context = MSIINSTALLCONTEXT_USERMANAGED;
  57     else if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
  58                                    &hkey, FALSE) == ERROR_SUCCESS)
  59         *context = MSIINSTALLCONTEXT_MACHINE;
  60     else if (MSIREG_OpenProductKey(szProduct, NULL,
  61                                    MSIINSTALLCONTEXT_USERUNMANAGED,
  62                                    &hkey, FALSE) == ERROR_SUCCESS)
  63         *context = MSIINSTALLCONTEXT_USERUNMANAGED;
  64
  65     RegCloseKey(hkey);
  66
  67     if (*context == MSIINSTALLCONTEXT_NONE)
  68         return ERROR_UNKNOWN_PRODUCT;
  69
  70     return ERROR_SUCCESS;
  71 }
  72
  73 UINT WINAPI MsiOpenProductA(LPCSTR szProduct, MSIHANDLE *phProduct)
  74 {
  75     UINT r;
  76     LPWSTR szwProd = NULL;
  77
  78     TRACE("%s %p\n",debugstr_a(szProduct), phProduct);
  79
  80     if( szProduct )
  81     {
  82         szwProd = strdupAtoW( szProduct );
  83         if( !szwProd )
  84             return ERROR_OUTOFMEMORY;
  85     }
  86
  87     r = MsiOpenProductW( szwProd, phProduct );
  88
  89     msi_free( szwProd );
  90
  91     return r;
  92 }
  93
  94 static UINT MSI_OpenProductW(LPCWSTR szProduct, MSIPACKAGE **package)
  95 {
  96     UINT r;
  97     HKEY props;
  98     LPWSTR path;
  99     MSIINSTALLCONTEXT context;
 100
 101     static const WCHAR managed[] = {
 102         'M','a','n','a','g','e','d','L','o','c','a','l','P','a','c','k','a','g','e',0};
 103     static const WCHAR local[] = {'L','o','c','a','l','P','a','c','k','a','g','e',0};
 104
 105     TRACE("%s %p\n", debugstr_w(szProduct), package);
 106
 107     r = msi_locate_product(szProduct, &context);
 108     if (r != ERROR_SUCCESS)
 109         return r;
 110
 111     r = MSIREG_OpenInstallProps(szProduct, context, NULL, &props, FALSE);
 112     if (r != ERROR_SUCCESS)
 113         return ERROR_UNKNOWN_PRODUCT;
 114
 115     if (context == MSIINSTALLCONTEXT_USERMANAGED)
 116         path = msi_reg_get_val_str(props, managed);
 117     else
 118         path = msi_reg_get_val_str(props, local);
 119
 120     r = ERROR_UNKNOWN_PRODUCT;
 121
 122     if (!path || GetFileAttributesW(path) == INVALID_FILE_ATTRIBUTES)
 123         goto done;
 124
 125     if (PathIsRelativeW(path))
 126     {
 127         r = ERROR_INSTALL_PACKAGE_OPEN_FAILED;
 128         goto done;
 129     }
 130
 131     r = MSI_OpenPackageW(path, package);
 132
 133 done:
 134     RegCloseKey(props);
 135     msi_free(path);
 136     return r;
 137 }
 138
 139 UINT WINAPI MsiOpenProductW(LPCWSTR szProduct, MSIHANDLE *phProduct)
 140 {
 141     MSIPACKAGE *package = NULL;
 142     WCHAR squished_pc[GUID_SIZE];
 143     UINT r;
 144
 145     if (!szProduct || !squash_guid(szProduct, squished_pc))
 146         return ERROR_INVALID_PARAMETER;
 147
 148     if (!phProduct)
 149         return ERROR_INVALID_PARAMETER;
 150
 151     r = MSI_OpenProductW(szProduct, &package);
 152     if (r != ERROR_SUCCESS)
 153         return r;
 154
 155     *phProduct = alloc_msihandle(&package->hdr);
 156     if (!*phProduct)
 157         r = ERROR_NOT_ENOUGH_MEMORY;
 158
 159     msiobj_release(&package->hdr);
 160     return r;
 161 }
 162
 163 UINT WINAPI MsiAdvertiseProductA(LPCSTR szPackagePath, LPCSTR szScriptfilePath,
 164                 LPCSTR szTransforms, LANGID lgidLanguage)
 165 {
 166     FIXME("%s %s %s %08x\n",debugstr_a(szPackagePath),
 167           debugstr_a(szScriptfilePath), debugstr_a(szTransforms), lgidLanguage);
 168     return ERROR_CALL_NOT_IMPLEMENTED;
 169 }
 170
 171 UINT WINAPI MsiAdvertiseProductW(LPCWSTR szPackagePath, LPCWSTR szScriptfilePath,
 172                 LPCWSTR szTransforms, LANGID lgidLanguage)
 173 {
 174     FIXME("%s %s %s %08x\n",debugstr_w(szPackagePath),
 175           debugstr_w(szScriptfilePath), debugstr_w(szTransforms), lgidLanguage);
 176     return ERROR_CALL_NOT_IMPLEMENTED;
 177 }
 178
 179 UINT WINAPI MsiAdvertiseProductExA(LPCSTR szPackagePath, LPCSTR szScriptfilePath,
 180       LPCSTR szTransforms, LANGID lgidLanguage, DWORD dwPlatform, DWORD dwOptions)
 181 {
 182     FIXME("%s %s %s %08x %08x %08x\n", debugstr_a(szPackagePath),
 183           debugstr_a(szScriptfilePath), debugstr_a(szTransforms),
 184           lgidLanguage, dwPlatform, dwOptions);
 185     return ERROR_CALL_NOT_IMPLEMENTED;
 186 }
 187
 188 UINT WINAPI MsiAdvertiseProductExW( LPCWSTR szPackagePath, LPCWSTR szScriptfilePath,
 189       LPCWSTR szTransforms, LANGID lgidLanguage, DWORD dwPlatform, DWORD dwOptions)
 190 {
 191     FIXME("%s %s %s %08x %08x %08x\n", debugstr_w(szPackagePath),
 192           debugstr_w(szScriptfilePath), debugstr_w(szTransforms),
 193           lgidLanguage, dwPlatform, dwOptions);
 194     return ERROR_CALL_NOT_IMPLEMENTED;
 195 }
 196
 197 UINT WINAPI MsiInstallProductA(LPCSTR szPackagePath, LPCSTR szCommandLine)
 198 {
 199     LPWSTR szwPath = NULL, szwCommand = NULL;
 200     UINT r = ERROR_OUTOFMEMORY;
 201
 202     TRACE("%s %s\n",debugstr_a(szPackagePath), debugstr_a(szCommandLine));
 203
 204     if( szPackagePath )
 205     {
 206         szwPath = strdupAtoW( szPackagePath );
 207         if( !szwPath )
 208             goto end;
 209     }
 210
 211     if( szCommandLine )
 212     {
 213         szwCommand = strdupAtoW( szCommandLine );
 214         if( !szwCommand )
 215             goto end;
 216     }
 217
 218     r = MsiInstallProductW( szwPath, szwCommand );
 219
 220 end:
 221     msi_free( szwPath );
 222     msi_free( szwCommand );
 223
 224     return r;
 225 }
 226
 227 UINT WINAPI MsiInstallProductW(LPCWSTR szPackagePath, LPCWSTR szCommandLine)
 228 {
 229     MSIPACKAGE *package = NULL;
 230     UINT r;
 231
 232     TRACE("%s %s\n",debugstr_w(szPackagePath), debugstr_w(szCommandLine));
 233
 234     if (!szPackagePath)
 235         return ERROR_INVALID_PARAMETER;
 236
 237     if (!*szPackagePath)
 238         return ERROR_PATH_NOT_FOUND;
 239
 240     r = MSI_OpenPackageW( szPackagePath, &package );
 241     if (r == ERROR_SUCCESS)
 242     {
 243         r = MSI_InstallPackage( package, szPackagePath, szCommandLine );
 244         msiobj_release( &package->hdr );
 245     }
 246
 247     return r;
 248 }
 249
 250 UINT WINAPI MsiReinstallProductA(LPCSTR szProduct, DWORD dwReinstallMode)
 251 {
 252     LPWSTR wszProduct;
 253     UINT rc;
 254
 255     TRACE("%s %08x\n", debugstr_a(szProduct), dwReinstallMode);
 256
 257     wszProduct = strdupAtoW(szProduct);
 258
 259     rc = MsiReinstallProductW(wszProduct, dwReinstallMode);
 260
 261     msi_free(wszProduct);
 262     return rc;
 263 }
 264
 265 UINT WINAPI MsiReinstallProductW(LPCWSTR szProduct, DWORD dwReinstallMode)
 266 {
 267     TRACE("%s %08x\n", debugstr_w(szProduct), dwReinstallMode);
 268
 269     return MsiReinstallFeatureW(szProduct, szAll, dwReinstallMode);
 270 }
 271
 272 UINT WINAPI MsiApplyPatchA(LPCSTR szPatchPackage, LPCSTR szInstallPackage,
 273         INSTALLTYPE eInstallType, LPCSTR szCommandLine)
 274 {
 275     LPWSTR patch_package = NULL;
 276     LPWSTR install_package = NULL;
 277     LPWSTR command_line = NULL;
 278     UINT r = ERROR_OUTOFMEMORY;
 279
 280     TRACE("%s %s %d %s\n", debugstr_a(szPatchPackage), debugstr_a(szInstallPackage),
 281           eInstallType, debugstr_a(szCommandLine));
 282
 283     if (szPatchPackage && !(patch_package = strdupAtoW(szPatchPackage)))
 284         goto done;
 285
 286     if (szInstallPackage && !(install_package = strdupAtoW(szInstallPackage)))
 287         goto done;
 288
 289     if (szCommandLine && !(command_line = strdupAtoW(szCommandLine)))
 290         goto done;
 291
 292     r = MsiApplyPatchW(patch_package, install_package, eInstallType, command_line);
 293
 294 done:
 295     msi_free(patch_package);
 296     msi_free(install_package);
 297     msi_free(command_line);
 298
 299     return r;
 300 }
 301
 302 static UINT get_patch_product_codes( LPCWSTR szPatchPackage, WCHAR **product_codes )
 303 {
 304     MSIHANDLE patch, info = 0;
 305     UINT r, type;
 306     DWORD size;
 307     static WCHAR empty[] = {0};
 308     WCHAR *codes;
 309
 310     r = MsiOpenDatabaseW( szPatchPackage, MSIDBOPEN_READONLY, &patch );
 311     if (r != ERROR_SUCCESS)
 312         return r;
 313
 314     r = MsiGetSummaryInformationW( patch, NULL, 0, &info );
 315     if (r != ERROR_SUCCESS)
 316         goto done;
 317
 318     size = 0;
 319     r = MsiSummaryInfoGetPropertyW( info, PID_TEMPLATE, &type, NULL, NULL, empty, &size );
 320     if (r != ERROR_MORE_DATA || !size || type != VT_LPSTR)
 321     {
 322         ERR("Failed to read product codes from patch\n");
 323         r = ERROR_FUNCTION_FAILED;
 324         goto done;
 325     }
 326
 327     codes = msi_alloc( ++size * sizeof(WCHAR) );
 328     if (!codes)
 329     {
 330         r = ERROR_OUTOFMEMORY;
 331         goto done;
 332     }
 333
 334     r = MsiSummaryInfoGetPropertyW( info, PID_TEMPLATE, &type, NULL, NULL, codes, &size );
 335     if (r != ERROR_SUCCESS)
 336         msi_free( codes );
 337     else
 338         *product_codes = codes;
 339
 340 done:
 341     MsiCloseHandle( info );
 342     MsiCloseHandle( patch );
 343     return r;
 344 }
 345
 346 static UINT MSI_ApplyPatchW(LPCWSTR szPatchPackage, LPCWSTR szProductCode, LPCWSTR szCommandLine)
 347 {
 348     UINT r;
 349     DWORD size;
 350     LPCWSTR cmd_ptr = szCommandLine;
 351     LPWSTR beg, end, cmd, codes = NULL;
 352     BOOL succeeded = FALSE;
 353
 354     static const WCHAR fmt[] = {'%','s',' ','P','A','T','C','H','=','"','%','s','"',0};
 355     static WCHAR empty[] = {0};
 356
 357     if (!szPatchPackage || !szPatchPackage[0])
 358         return ERROR_INVALID_PARAMETER;
 359
 360     if (!szProductCode && (r = get_patch_product_codes( szPatchPackage, &codes )))
 361         return r;
 362
 363     if (!szCommandLine)
 364         cmd_ptr = empty;
 365
 366     size = strlenW(cmd_ptr) + strlenW(fmt) + strlenW(szPatchPackage) + 1;
 367     cmd = msi_alloc(size * sizeof(WCHAR));
 368     if (!cmd)
 369     {
 370         msi_free(codes);
 371         return ERROR_OUTOFMEMORY;
 372     }
 373     sprintfW(cmd, fmt, cmd_ptr, szPatchPackage);
 374
 375     if (szProductCode)
 376         r = MsiConfigureProductExW(szProductCode, INSTALLLEVEL_DEFAULT, INSTALLSTATE_DEFAULT, cmd);
 377     else
 378     {
 379         beg = codes;
 380         while ((end = strchrW(beg, '}')))
 381         {
 382             *(end + 1) = '\0';
 383             r = MsiConfigureProductExW(beg, INSTALLLEVEL_DEFAULT, INSTALLSTATE_DEFAULT, cmd);
 384             if (r == ERROR_SUCCESS)
 385             {
 386                 TRACE("patch applied\n");
 387                 succeeded = TRUE;
 388             }
 389             beg = end + 2;
 390         }
 391
 392         if (succeeded)
 393             r = ERROR_SUCCESS;
 394     }
 395
 396     msi_free(cmd);
 397     msi_free(codes);
 398     return r;
 399 }
 400
 401 UINT WINAPI MsiApplyPatchW(LPCWSTR szPatchPackage, LPCWSTR szInstallPackage,
 402          INSTALLTYPE eInstallType, LPCWSTR szCommandLine)
 403 {
 404     TRACE("%s %s %d %s\n", debugstr_w(szPatchPackage), debugstr_w(szInstallPackage),
 405           eInstallType, debugstr_w(szCommandLine));
 406
 407     if (szInstallPackage || eInstallType == INSTALLTYPE_NETWORK_IMAGE ||
 408         eInstallType == INSTALLTYPE_SINGLE_INSTANCE)
 409     {
 410         FIXME("Only reading target products from patch\n");
 411         return ERROR_CALL_NOT_IMPLEMENTED;
 412     }
 413
 414     return MSI_ApplyPatchW(szPatchPackage, NULL, szCommandLine);
 415 }
 416
 417 UINT WINAPI MsiApplyMultiplePatchesA(LPCSTR szPatchPackages,
 418         LPCSTR szProductCode, LPCSTR szPropertiesList)
 419 {
 420     LPWSTR patch_packages = NULL;
 421     LPWSTR product_code = NULL;
 422     LPWSTR properties_list = NULL;
 423     UINT r = ERROR_OUTOFMEMORY;
 424
 425     TRACE("%s %s %s\n", debugstr_a(szPatchPackages), debugstr_a(szProductCode),
 426           debugstr_a(szPropertiesList));
 427
 428     if (!szPatchPackages || !szPatchPackages[0])
 429         return ERROR_INVALID_PARAMETER;
 430
 431     if (!(patch_packages = strdupAtoW(szPatchPackages)))
 432         return ERROR_OUTOFMEMORY;
 433
 434     if (szProductCode && !(product_code = strdupAtoW(szProductCode)))
 435         goto done;
 436
 437     if (szPropertiesList && !(properties_list = strdupAtoW(szPropertiesList)))
 438         goto done;
 439
 440     r = MsiApplyMultiplePatchesW(patch_packages, product_code, properties_list);
 441
 442 done:
 443     msi_free(patch_packages);
 444     msi_free(product_code);
 445     msi_free(properties_list);
 446
 447     return r;
 448 }
 449
 450 UINT WINAPI MsiApplyMultiplePatchesW(LPCWSTR szPatchPackages,
 451         LPCWSTR szProductCode, LPCWSTR szPropertiesList)
 452 {
 453     UINT r = ERROR_SUCCESS;
 454     LPCWSTR beg, end;
 455
 456     TRACE("%s %s %s\n", debugstr_w(szPatchPackages), debugstr_w(szProductCode),
 457           debugstr_w(szPropertiesList));
 458
 459     if (!szPatchPackages || !szPatchPackages[0])
 460         return ERROR_INVALID_PARAMETER;
 461
 462     beg = end = szPatchPackages;
 463     while (*beg)
 464     {
 465         DWORD len;
 466         LPWSTR patch;
 467
 468         while (*beg == ' ') beg++;
 469         while (*end && *end != ';') end++;
 470
 471         len = end - beg;
 472         while (len && beg[len - 1] == ' ') len--;
 473
 474         if (!len) return ERROR_INVALID_NAME;
 475
 476         patch = msi_alloc((len + 1) * sizeof(WCHAR));
 477         if (!patch)
 478             return ERROR_OUTOFMEMORY;
 479
 480         memcpy(patch, beg, len * sizeof(WCHAR));
 481         patch[len] = '\0';
 482
 483         r = MSI_ApplyPatchW(patch, szProductCode, szPropertiesList);
 484         msi_free(patch);
 485
 486         if (r != ERROR_SUCCESS)
 487             break;
 488
 489         beg = ++end;
 490     }
 491     return r;
 492 }
 493
 494 UINT WINAPI MsiDetermineApplicablePatchesA(LPCSTR szProductPackagePath,
 495         DWORD cPatchInfo, PMSIPATCHSEQUENCEINFOA pPatchInfo)
 496 {
 497     UINT i, r;
 498     WCHAR *package_path = NULL;
 499     MSIPATCHSEQUENCEINFOW *psi;
 500
 501     TRACE("(%s, %d, %p)\n", debugstr_a(szProductPackagePath), cPatchInfo, pPatchInfo);
 502
 503     if (szProductPackagePath && !(package_path = strdupAtoW( szProductPackagePath )))
 504         return ERROR_OUTOFMEMORY;
 505
 506     psi = msi_alloc( cPatchInfo * sizeof(*psi) );
 507     if (!psi)
 508     {
 509         msi_free( package_path );
 510         return ERROR_OUTOFMEMORY;
 511     }
 512
 513     for (i = 0; i < cPatchInfo; i++)
 514     {
 515         psi[i].szPatchData = strdupAtoW( pPatchInfo[i].szPatchData );
 516         psi[i].ePatchDataType = pPatchInfo[i].ePatchDataType;
 517     }
 518
 519     r = MsiDetermineApplicablePatchesW( package_path, cPatchInfo, psi );
 520     if (r == ERROR_SUCCESS)
 521     {
 522         for (i = 0; i < cPatchInfo; i++)
 523         {
 524             pPatchInfo[i].dwOrder = psi[i].dwOrder;
 525             pPatchInfo[i].uStatus = psi[i].uStatus;
 526         }
 527     }
 528
 529     msi_free( package_path );
 530     for (i = 0; i < cPatchInfo; i++)
 531         msi_free( (WCHAR *)psi[i].szPatchData );
 532     msi_free( psi );
 533     return r;
 534 }
 535
 536 static UINT MSI_ApplicablePatchW( MSIPACKAGE *package, LPCWSTR patch )
 537 {
 538     MSISUMMARYINFO *si;
 539     MSIDATABASE *patch_db;
 540     UINT r = ERROR_SUCCESS;
 541
 542     r = MSI_OpenDatabaseW( patch, MSIDBOPEN_READONLY, &patch_db );
 543     if (r != ERROR_SUCCESS)
 544     {
 545         WARN("failed to open patch file %s\n", debugstr_w(patch));
 546         return r;
 547     }
 548
 549     si = MSI_GetSummaryInformationW( patch_db->storage, 0 );
 550     if (!si)
 551     {
 552         msiobj_release( &patch_db->hdr );
 553         return ERROR_FUNCTION_FAILED;
 554     }
 555
 556     r = msi_check_patch_applicable( package, si );
 557     if (r != ERROR_SUCCESS)
 558         TRACE("patch not applicable\n");
 559
 560     msiobj_release( &patch_db->hdr );
 561     msiobj_release( &si->hdr );
 562     return r;
 563 }
 564
 565 UINT WINAPI MsiDetermineApplicablePatchesW(LPCWSTR szProductPackagePath,
 566         DWORD cPatchInfo, PMSIPATCHSEQUENCEINFOW pPatchInfo)
 567 {
 568     UINT i, r, ret = ERROR_FUNCTION_FAILED;
 569     MSIPACKAGE *package;
 570
 571     TRACE("(%s, %d, %p)\n", debugstr_w(szProductPackagePath), cPatchInfo, pPatchInfo);
 572
 573     r = MSI_OpenPackageW( szProductPackagePath, &package );
 574     if (r != ERROR_SUCCESS)
 575     {
 576         ERR("failed to open package %u\n", r);
 577         return r;
 578     }
 579
 580     for (i = 0; i < cPatchInfo; i++)
 581     {
 582         switch (pPatchInfo[i].ePatchDataType)
 583         {
 584         case MSIPATCH_DATATYPE_PATCHFILE:
 585         {
 586             FIXME("patch ordering not supported\n");
 587             r = MSI_ApplicablePatchW( package, pPatchInfo[i].szPatchData );
 588             if (r != ERROR_SUCCESS)
 589             {
 590                 pPatchInfo[i].dwOrder = ~0u;
 591                 pPatchInfo[i].uStatus = ERROR_PATCH_TARGET_NOT_FOUND;
 592             }
 593             else
 594             {
 595                 pPatchInfo[i].dwOrder = i;
 596                 pPatchInfo[i].uStatus = ret = ERROR_SUCCESS;
 597             }
 598             break;
 599         }
 600         default:
 601         {
 602             FIXME("patch data type %u not supported\n", pPatchInfo[i].ePatchDataType);
 603             pPatchInfo[i].dwOrder = ~0u;
 604             pPatchInfo[i].uStatus = ERROR_PATCH_TARGET_NOT_FOUND;
 605             break;
 606         }
 607         }
 608
 609         TRACE("   szPatchData: %s\n", debugstr_w(pPatchInfo[i].szPatchData));
 610         TRACE("ePatchDataType: %u\n", pPatchInfo[i].ePatchDataType);
 611         TRACE("       dwOrder: %u\n", pPatchInfo[i].dwOrder);
 612         TRACE("       uStatus: %u\n", pPatchInfo[i].uStatus);
 613     }
 614     return ret;
 615 }
 616
 617 UINT WINAPI MsiDeterminePatchSequenceA(LPCSTR szProductCode, LPCSTR szUserSid,
 618     MSIINSTALLCONTEXT dwContext, DWORD cPatchInfo, PMSIPATCHSEQUENCEINFOA pPatchInfo)
 619 {
 620     FIXME("(%s, %s, %d, %d, %p): stub!\n", debugstr_a(szProductCode),
 621           debugstr_a(szUserSid), dwContext, cPatchInfo, pPatchInfo);
 622
 623     return ERROR_CALL_NOT_IMPLEMENTED;
 624 }
 625
 626 UINT WINAPI MsiDeterminePatchSequenceW(LPCWSTR szProductCode, LPCWSTR szUserSid,
 627     MSIINSTALLCONTEXT dwContext, DWORD cPatchInfo, PMSIPATCHSEQUENCEINFOW pPatchInfo)
 628 {
 629     FIXME("(%s, %s, %d, %d, %p): stub!\n", debugstr_w(szProductCode),
 630           debugstr_w(szUserSid), dwContext, cPatchInfo, pPatchInfo);
 631
 632     return ERROR_CALL_NOT_IMPLEMENTED;
 633 }
 634
 635 static UINT msi_open_package(LPCWSTR product, MSIINSTALLCONTEXT context,
 636                              MSIPACKAGE **package)
 637 {
 638     UINT r;
 639     DWORD sz;
 640     HKEY props;
 641     LPWSTR localpack;
 642     WCHAR sourcepath[MAX_PATH];
 643     WCHAR filename[MAX_PATH];
 644
 645     r = MSIREG_OpenInstallProps(product, context, NULL, &props, FALSE);
 646     if (r != ERROR_SUCCESS)
 647         return ERROR_BAD_CONFIGURATION;
 648
 649     localpack = msi_reg_get_val_str(props, szLocalPackage);
 650     if (localpack)
 651     {
 652         lstrcpyW(sourcepath, localpack);
 653         msi_free(localpack);
 654     }
 655
 656     if (!localpack || GetFileAttributesW(sourcepath) == INVALID_FILE_ATTRIBUTES)
 657     {
 658         sz = sizeof(sourcepath);
 659         MsiSourceListGetInfoW(product, NULL, context, MSICODE_PRODUCT,
 660                               INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
 661
 662         sz = sizeof(filename);
 663         MsiSourceListGetInfoW(product, NULL, context, MSICODE_PRODUCT,
 664                               INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
 665
 666         lstrcatW(sourcepath, filename);
 667     }
 668
 669     if (GetFileAttributesW(sourcepath) == INVALID_FILE_ATTRIBUTES)
 670         return ERROR_INSTALL_SOURCE_ABSENT;
 671
 672     return MSI_OpenPackageW(sourcepath, package);
 673 }
 674
 675 UINT WINAPI MsiConfigureProductExW(LPCWSTR szProduct, int iInstallLevel,
 676                         INSTALLSTATE eInstallState, LPCWSTR szCommandLine)
 677 {
 678     MSIPACKAGE* package = NULL;
 679     MSIINSTALLCONTEXT context;
 680     UINT r;
 681     DWORD sz;
 682     WCHAR sourcepath[MAX_PATH], filename[MAX_PATH];
 683     LPWSTR commandline;
 684
 685     static const WCHAR szInstalled[] = {
 686         ' ','I','n','s','t','a','l','l','e','d','=','1',0};
 687     static const WCHAR szInstallLevel[] = {
 688         ' ','I','N','S','T','A','L','L','L','E','V','E','L','=','3','2','7','6','7',0};
 689     static const WCHAR szRemoveAll[] = {
 690         ' ','R','E','M','O','V','E','=','A','L','L',0};
 691     static const WCHAR szMachine[] = {
 692         ' ','A','L','L','U','S','E','R','S','=','1',0};
 693
 694     TRACE("%s %d %d %s\n",debugstr_w(szProduct), iInstallLevel, eInstallState,
 695           debugstr_w(szCommandLine));
 696
 697     if (!szProduct || lstrlenW(szProduct) != GUID_SIZE - 1)
 698         return ERROR_INVALID_PARAMETER;
 699
 700     if (eInstallState == INSTALLSTATE_ADVERTISED ||
 701         eInstallState == INSTALLSTATE_SOURCE)
 702     {
 703         FIXME("State %d not implemented\n", eInstallState);
 704         return ERROR_CALL_NOT_IMPLEMENTED;
 705     }
 706
 707     r = msi_locate_product(szProduct, &context);
 708     if (r != ERROR_SUCCESS)
 709         return r;
 710
 711     r = msi_open_package(szProduct, context, &package);
 712     if (r != ERROR_SUCCESS)
 713         return r;
 714
 715     sz = lstrlenW(szInstalled) + 1;
 716
 717     if (szCommandLine)
 718         sz += lstrlenW(szCommandLine);
 719
 720     if (eInstallState != INSTALLSTATE_DEFAULT)
 721         sz += lstrlenW(szInstallLevel);
 722
 723     if (eInstallState == INSTALLSTATE_ABSENT)
 724         sz += lstrlenW(szRemoveAll);
 725
 726     if (context == MSIINSTALLCONTEXT_MACHINE)
 727         sz += lstrlenW(szMachine);
 728
 729     commandline = msi_alloc(sz * sizeof(WCHAR));
 730     if (!commandline)
 731     {
 732         r = ERROR_OUTOFMEMORY;
 733         goto end;
 734     }
 735
 736     commandline[0] = 0;
 737     if (szCommandLine)
 738         lstrcpyW(commandline,szCommandLine);
 739
 740     if (eInstallState != INSTALLSTATE_DEFAULT)
 741         lstrcatW(commandline, szInstallLevel);
 742
 743     if (eInstallState == INSTALLSTATE_ABSENT)
 744         lstrcatW(commandline, szRemoveAll);
 745
 746     if (context == MSIINSTALLCONTEXT_MACHINE)
 747         lstrcatW(commandline, szMachine);
 748
 749     sz = sizeof(sourcepath);
 750     MsiSourceListGetInfoW(szProduct, NULL, context, MSICODE_PRODUCT,
 751                           INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
 752
 753     sz = sizeof(filename);
 754     MsiSourceListGetInfoW(szProduct, NULL, context, MSICODE_PRODUCT,
 755                           INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
 756
 757     strcatW(sourcepath, filename);
 758
 759     r = MSI_InstallPackage( package, sourcepath, commandline );
 760
 761     msi_free(commandline);
 762
 763 end:
 764     msiobj_release( &package->hdr );
 765
 766     return r;
 767 }
 768
 769 UINT WINAPI MsiConfigureProductExA(LPCSTR szProduct, int iInstallLevel,
 770                         INSTALLSTATE eInstallState, LPCSTR szCommandLine)
 771 {
 772     LPWSTR szwProduct = NULL;
 773     LPWSTR szwCommandLine = NULL;
 774     UINT r = ERROR_OUTOFMEMORY;
 775
 776     if( szProduct )
 777     {
 778         szwProduct = strdupAtoW( szProduct );
 779         if( !szwProduct )
 780             goto end;
 781     }
 782
 783     if( szCommandLine)
 784     {
 785         szwCommandLine = strdupAtoW( szCommandLine );
 786         if( !szwCommandLine)
 787             goto end;
 788     }
 789
 790     r = MsiConfigureProductExW( szwProduct, iInstallLevel, eInstallState,
 791                                 szwCommandLine );
 792 end:
 793     msi_free( szwProduct );
 794     msi_free( szwCommandLine);
 795
 796     return r;
 797 }
 798
 799 UINT WINAPI MsiConfigureProductA(LPCSTR szProduct, int iInstallLevel,
 800                                  INSTALLSTATE eInstallState)
 801 {
 802     LPWSTR szwProduct = NULL;
 803     UINT r;
 804
 805     TRACE("%s %d %d\n",debugstr_a(szProduct), iInstallLevel, eInstallState);
 806
 807     if( szProduct )
 808     {
 809         szwProduct = strdupAtoW( szProduct );
 810         if( !szwProduct )
 811             return ERROR_OUTOFMEMORY;
 812     }
 813
 814     r = MsiConfigureProductW( szwProduct, iInstallLevel, eInstallState );
 815     msi_free( szwProduct );
 816
 817     return r;
 818 }
 819
 820 UINT WINAPI MsiConfigureProductW(LPCWSTR szProduct, int iInstallLevel,
 821                                  INSTALLSTATE eInstallState)
 822 {
 823     return MsiConfigureProductExW(szProduct, iInstallLevel, eInstallState, NULL);
 824 }
 825
 826 UINT WINAPI MsiGetProductCodeA(LPCSTR szComponent, LPSTR szBuffer)
 827 {
 828     LPWSTR szwComponent = NULL;
 829     UINT r;
 830     WCHAR szwBuffer[GUID_SIZE];
 831
 832     TRACE("%s %p\n", debugstr_a(szComponent), szBuffer);
 833
 834     if( szComponent )
 835     {
 836         szwComponent = strdupAtoW( szComponent );
 837         if( !szwComponent )
 838             return ERROR_OUTOFMEMORY;
 839     }
 840
 841     *szwBuffer = '\0';
 842     r = MsiGetProductCodeW( szwComponent, szwBuffer );
 843
 844     if(*szwBuffer)
 845         WideCharToMultiByte(CP_ACP, 0, szwBuffer, -1, szBuffer, GUID_SIZE, NULL, NULL);
 846
 847     msi_free( szwComponent );
 848
 849     return r;
 850 }
 851
 852 UINT WINAPI MsiGetProductCodeW(LPCWSTR szComponent, LPWSTR szBuffer)
 853 {
 854     UINT rc, index;
 855     HKEY compkey, prodkey;
 856     WCHAR squished_comp[GUID_SIZE];
 857     WCHAR squished_prod[GUID_SIZE];
 858     DWORD sz = GUID_SIZE;
 859
 860     TRACE("%s %p\n", debugstr_w(szComponent), szBuffer);
 861
 862     if (!szComponent || !*szComponent)
 863         return ERROR_INVALID_PARAMETER;
 864
 865     if (!squash_guid(szComponent, squished_comp))
 866         return ERROR_INVALID_PARAMETER;
 867
 868     if (MSIREG_OpenUserDataComponentKey(szComponent, NULL, &compkey, FALSE) != ERROR_SUCCESS &&
 869         MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &compkey, FALSE) != ERROR_SUCCESS)
 870     {
 871         return ERROR_UNKNOWN_COMPONENT;
 872     }
 873
 874     rc = RegEnumValueW(compkey, 0, squished_prod, &sz, NULL, NULL, NULL, NULL);
 875     if (rc != ERROR_SUCCESS)
 876     {
 877         RegCloseKey(compkey);
 878         return ERROR_UNKNOWN_COMPONENT;
 879     }
 880
 881     /* check simple case, only one product */
 882     rc = RegEnumValueW(compkey, 1, squished_prod, &sz, NULL, NULL, NULL, NULL);
 883     if (rc == ERROR_NO_MORE_ITEMS)
 884     {
 885         rc = ERROR_SUCCESS;
 886         goto done;
 887     }
 888
 889     index = 0;
 890     while ((rc = RegEnumValueW(compkey, index, squished_prod, &sz,
 891            NULL, NULL, NULL, NULL)) != ERROR_NO_MORE_ITEMS)
 892     {
 893         index++;
 894         sz = GUID_SIZE;
 895         unsquash_guid(squished_prod, szBuffer);
 896
 897         if (MSIREG_OpenProductKey(szBuffer, NULL,
 898                                   MSIINSTALLCONTEXT_USERMANAGED,
 899                                   &prodkey, FALSE) == ERROR_SUCCESS ||
 900             MSIREG_OpenProductKey(szBuffer, NULL,
 901                                   MSIINSTALLCONTEXT_USERUNMANAGED,
 902                                   &prodkey, FALSE) == ERROR_SUCCESS ||
 903             MSIREG_OpenProductKey(szBuffer, NULL,
 904                                   MSIINSTALLCONTEXT_MACHINE,
 905                                   &prodkey, FALSE) == ERROR_SUCCESS)
 906         {
 907             RegCloseKey(prodkey);
 908             rc = ERROR_SUCCESS;
 909             goto done;
 910         }
 911     }
 912
 913     rc = ERROR_INSTALL_FAILURE;
 914
 915 done:
 916     RegCloseKey(compkey);
 917     unsquash_guid(squished_prod, szBuffer);
 918     return rc;
 919 }
 920
 921 static LPWSTR msi_reg_get_value(HKEY hkey, LPCWSTR name, DWORD *type)
 922 {
 923     DWORD dval;
 924     LONG res;
 925     WCHAR temp[20];
 926
 927     static const WCHAR format[] = {'%','d',0};
 928
 929     res = RegQueryValueExW(hkey, name, NULL, type, NULL, NULL);
 930     if (res != ERROR_SUCCESS)
 931         return NULL;
 932
 933     if (*type == REG_SZ)
 934         return msi_reg_get_val_str(hkey, name);
 935
 936     if (!msi_reg_get_val_dword(hkey, name, &dval))
 937         return NULL;
 938
 939     sprintfW(temp, format, dval);
 940     return strdupW(temp);
 941 }
 942
 943 static UINT MSI_GetProductInfo(LPCWSTR szProduct, LPCWSTR szAttribute,
 944                                awstring *szValue, LPDWORD pcchValueBuf)
 945 {
 946     MSIINSTALLCONTEXT context = MSIINSTALLCONTEXT_USERUNMANAGED;
 947     UINT r = ERROR_UNKNOWN_PROPERTY;
 948     HKEY prodkey, userdata, source;
 949     LPWSTR val = NULL;
 950     WCHAR squished_pc[GUID_SIZE];
 951     WCHAR packagecode[GUID_SIZE];
 952     BOOL badconfig = FALSE;
 953     LONG res;
 954     DWORD type = REG_NONE;
 955
 956     static WCHAR empty[] = {0};
 957     static const WCHAR sourcelist[] = {
 958         'S','o','u','r','c','e','L','i','s','t',0};
 959     static const WCHAR display_name[] = {
 960         'D','i','s','p','l','a','y','N','a','m','e',0};
 961     static const WCHAR display_version[] = {
 962         'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0};
 963     static const WCHAR assignment[] = {
 964         'A','s','s','i','g','n','m','e','n','t',0};
 965
 966     TRACE("%s %s %p %p\n", debugstr_w(szProduct),
 967           debugstr_w(szAttribute), szValue, pcchValueBuf);
 968
 969     if ((szValue->str.w && !pcchValueBuf) || !szProduct || !szAttribute)
 970         return ERROR_INVALID_PARAMETER;
 971
 972     if (!squash_guid(szProduct, squished_pc))
 973         return ERROR_INVALID_PARAMETER;
 974
 975     if ((r = MSIREG_OpenProductKey(szProduct, NULL,
 976                                    MSIINSTALLCONTEXT_USERMANAGED,
 977                                    &prodkey, FALSE)) != ERROR_SUCCESS &&
 978         (r = MSIREG_OpenProductKey(szProduct, NULL,
 979                                    MSIINSTALLCONTEXT_USERUNMANAGED,
 980                                    &prodkey, FALSE)) != ERROR_SUCCESS &&
 981         (r = MSIREG_OpenProductKey(szProduct, NULL,
 982                                    MSIINSTALLCONTEXT_MACHINE,
 983                                     &prodkey, FALSE)) == ERROR_SUCCESS)
 984     {
 985         context = MSIINSTALLCONTEXT_MACHINE;
 986     }
 987
 988     MSIREG_OpenInstallProps(szProduct, context, NULL, &userdata, FALSE);
 989
 990     if (!strcmpW( szAttribute, INSTALLPROPERTY_HELPLINKW ) ||
 991         !strcmpW( szAttribute, INSTALLPROPERTY_HELPTELEPHONEW ) ||
 992         !strcmpW( szAttribute, INSTALLPROPERTY_INSTALLDATEW ) ||
 993         !strcmpW( szAttribute, INSTALLPROPERTY_INSTALLEDPRODUCTNAMEW ) ||
 994         !strcmpW( szAttribute, INSTALLPROPERTY_INSTALLLOCATIONW ) ||
 995         !strcmpW( szAttribute, INSTALLPROPERTY_INSTALLSOURCEW ) ||
 996         !strcmpW( szAttribute, INSTALLPROPERTY_LOCALPACKAGEW ) ||
 997         !strcmpW( szAttribute, INSTALLPROPERTY_PUBLISHERW ) ||
 998         !strcmpW( szAttribute, INSTALLPROPERTY_URLINFOABOUTW ) ||
 999         !strcmpW( szAttribute, INSTALLPROPERTY_URLUPDATEINFOW ) ||
1000         !strcmpW( szAttribute, INSTALLPROPERTY_VERSIONMINORW ) ||
1001         !strcmpW( szAttribute, INSTALLPROPERTY_VERSIONMAJORW ) ||
1002         !strcmpW( szAttribute, INSTALLPROPERTY_VERSIONSTRINGW ) ||
1003         !strcmpW( szAttribute, INSTALLPROPERTY_PRODUCTIDW ) ||
1004         !strcmpW( szAttribute, INSTALLPROPERTY_REGCOMPANYW ) ||
1005         !strcmpW( szAttribute, INSTALLPROPERTY_REGOWNERW ))
1006     {
1007         if (!prodkey)
1008         {
1009             r = ERROR_UNKNOWN_PRODUCT;
1010             goto done;
1011         }
1012
1013         if (!userdata)
1014             return ERROR_UNKNOWN_PROPERTY;
1015
1016         if (!strcmpW( szAttribute, INSTALLPROPERTY_INSTALLEDPRODUCTNAMEW ))
1017             szAttribute = display_name;
1018         else if (!strcmpW( szAttribute, INSTALLPROPERTY_VERSIONSTRINGW ))
1019             szAttribute = display_version;
1020
1021         val = msi_reg_get_value(userdata, szAttribute, &type);
1022         if (!val)
1023             val = empty;
1024     }
1025     else if (!strcmpW( szAttribute, INSTALLPROPERTY_INSTANCETYPEW ) ||
1026              !strcmpW( szAttribute, INSTALLPROPERTY_TRANSFORMSW ) ||
1027              !strcmpW( szAttribute, INSTALLPROPERTY_LANGUAGEW ) ||
1028              !strcmpW( szAttribute, INSTALLPROPERTY_PRODUCTNAMEW ) ||
1029              !strcmpW( szAttribute, INSTALLPROPERTY_ASSIGNMENTTYPEW ) ||
1030              !strcmpW( szAttribute, INSTALLPROPERTY_PACKAGECODEW ) ||
1031              !strcmpW( szAttribute, INSTALLPROPERTY_VERSIONW ) ||
1032              !strcmpW( szAttribute, INSTALLPROPERTY_PRODUCTICONW ) ||
1033              !strcmpW( szAttribute, INSTALLPROPERTY_PACKAGENAMEW ) ||
1034              !strcmpW( szAttribute, INSTALLPROPERTY_AUTHORIZED_LUA_APPW ))
1035     {
1036         if (!prodkey)
1037         {
1038             r = ERROR_UNKNOWN_PRODUCT;
1039             goto done;
1040         }
1041
1042         if (!strcmpW( szAttribute, INSTALLPROPERTY_ASSIGNMENTTYPEW ))
1043             szAttribute = assignment;
1044
1045         if (!strcmpW( szAttribute, INSTALLPROPERTY_PACKAGENAMEW ))
1046         {
1047             res = RegOpenKeyW(prodkey, sourcelist, &source);
1048             if (res != ERROR_SUCCESS)
1049             {
1050                 r = ERROR_UNKNOWN_PRODUCT;
1051                 goto done;
1052             }
1053
1054             val = msi_reg_get_value(source, szAttribute, &type);
1055             if (!val)
1056                 val = empty;
1057
1058             RegCloseKey(source);
1059         }
1060         else
1061         {
1062             val = msi_reg_get_value(prodkey, szAttribute, &type);
1063             if (!val)
1064                 val = empty;
1065         }
1066
1067         if (val != empty && type != REG_DWORD &&
1068             !strcmpW( szAttribute, INSTALLPROPERTY_PACKAGECODEW ))
1069         {
1070             if (lstrlenW(val) != SQUISH_GUID_SIZE - 1)
1071                 badconfig = TRUE;
1072             else
1073             {
1074                 unsquash_guid(val, packagecode);
1075                 msi_free(val);
1076                 val = strdupW(packagecode);
1077             }
1078         }
1079     }
1080
1081     if (!val)
1082     {
1083         r = ERROR_UNKNOWN_PROPERTY;
1084         goto done;
1085     }
1086
1087     if (pcchValueBuf)
1088     {
1089         /* If szBuffer (szValue->str) is NULL, there's no need to copy the value
1090          * out.  Also, *pcchValueBuf may be uninitialized in this case, so we
1091          * can't rely on its value.
1092          */
1093         if (szValue->str.a || szValue->str.w)
1094         {
1095             DWORD size = *pcchValueBuf;
1096             if (strlenW(val) < size)
1097                 r = msi_strcpy_to_awstring(val, szValue, &size);
1098             else
1099             {
1100                 r = ERROR_MORE_DATA;
1101             }
1102         }
1103
1104         if (!badconfig)
1105             *pcchValueBuf = lstrlenW(val);
1106     }
1107
1108     if (badconfig)
1109         r = ERROR_BAD_CONFIGURATION;
1110
1111     if (val != empty)
1112         msi_free(val);
1113
1114 done:
1115     RegCloseKey(prodkey);
1116     RegCloseKey(userdata);
1117     return r;
1118 }
1119
1120 UINT WINAPI MsiGetProductInfoA(LPCSTR szProduct, LPCSTR szAttribute,
1121                                LPSTR szBuffer, LPDWORD pcchValueBuf)
1122 {
1123     LPWSTR szwProduct, szwAttribute = NULL;
1124     UINT r = ERROR_OUTOFMEMORY;
1125     awstring buffer;
1126
1127     TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szAttribute),
1128           szBuffer, pcchValueBuf);
1129
1130     szwProduct = strdupAtoW( szProduct );
1131     if( szProduct && !szwProduct )
1132         goto end;
1133
1134     szwAttribute = strdupAtoW( szAttribute );
1135     if( szAttribute && !szwAttribute )
1136         goto end;
1137
1138     buffer.unicode = FALSE;
1139     buffer.str.a = szBuffer;
1140
1141     r = MSI_GetProductInfo( szwProduct, szwAttribute,
1142                             &buffer, pcchValueBuf );
1143
1144 end:
1145     msi_free( szwProduct );
1146     msi_free( szwAttribute );
1147
1148     return r;
1149 }
1150
1151 UINT WINAPI MsiGetProductInfoW(LPCWSTR szProduct, LPCWSTR szAttribute,
1152                                LPWSTR szBuffer, LPDWORD pcchValueBuf)
1153 {
1154     awstring buffer;
1155
1156     TRACE("%s %s %p %p\n", debugstr_w(szProduct), debugstr_w(szAttribute),
1157           szBuffer, pcchValueBuf);
1158
1159     buffer.unicode = TRUE;
1160     buffer.str.w = szBuffer;
1161
1162     return MSI_GetProductInfo( szProduct, szAttribute,
1163                                &buffer, pcchValueBuf );
1164 }
1165
1166 UINT WINAPI MsiGetProductInfoExA(LPCSTR szProductCode, LPCSTR szUserSid,
1167                                  MSIINSTALLCONTEXT dwContext, LPCSTR szProperty,
1168                                  LPSTR szValue, LPDWORD pcchValue)
1169 {
1170     LPWSTR product = NULL;
1171     LPWSTR usersid = NULL;
1172     LPWSTR property = NULL;
1173     LPWSTR value = NULL;
1174     DWORD len = 0;
1175     UINT r;
1176
1177     TRACE("(%s, %s, %d, %s, %p, %p)\n", debugstr_a(szProductCode),
1178           debugstr_a(szUserSid), dwContext, debugstr_a(szProperty),
1179            szValue, pcchValue);
1180
1181     if (szValue && !pcchValue)
1182         return ERROR_INVALID_PARAMETER;
1183
1184     if (szProductCode) product = strdupAtoW(szProductCode);
1185     if (szUserSid) usersid = strdupAtoW(szUserSid);
1186     if (szProperty) property = strdupAtoW(szProperty);
1187
1188     r = MsiGetProductInfoExW(product, usersid, dwContext, property,
1189                              NULL, &len);
1190     if (r != ERROR_SUCCESS)
1191         goto done;
1192
1193     value = msi_alloc(++len * sizeof(WCHAR));
1194     if (!value)
1195     {
1196         r = ERROR_OUTOFMEMORY;
1197         goto done;
1198     }
1199
1200     r = MsiGetProductInfoExW(product, usersid, dwContext, property,
1201                              value, &len);
1202     if (r != ERROR_SUCCESS)
1203         goto done;
1204
1205     if (!pcchValue)
1206         goto done;
1207
1208     len = WideCharToMultiByte(CP_ACP, 0, value, -1, NULL, 0, NULL, NULL);
1209     if (*pcchValue >= len)
1210         WideCharToMultiByte(CP_ACP, 0, value, -1, szValue, len, NULL, NULL);
1211     else if (szValue)
1212     {
1213         r = ERROR_MORE_DATA;
1214         if (*pcchValue > 0)
1215             *szValue = '\0';
1216     }
1217
1218     if (*pcchValue <= len || !szValue)
1219         len = len * sizeof(WCHAR) - 1;
1220
1221     *pcchValue = len - 1;
1222
1223 done:
1224     msi_free(product);
1225     msi_free(usersid);
1226     msi_free(property);
1227     msi_free(value);
1228
1229     return r;
1230 }
1231
1232 static UINT msi_copy_outval(LPWSTR val, LPWSTR out, LPDWORD size)
1233 {
1234     UINT r = ERROR_SUCCESS;
1235
1236     if (!val)
1237         return ERROR_UNKNOWN_PROPERTY;
1238
1239     if (out)
1240     {
1241         if (strlenW(val) >= *size)
1242         {
1243             r = ERROR_MORE_DATA;
1244             if (*size > 0)
1245                 *out = '\0';
1246         }
1247         else
1248             lstrcpyW(out, val);
1249     }
1250
1251     if (size)
1252         *size = lstrlenW(val);
1253
1254     return r;
1255 }
1256
1257 UINT WINAPI MsiGetProductInfoExW(LPCWSTR szProductCode, LPCWSTR szUserSid,
1258                                  MSIINSTALLCONTEXT dwContext, LPCWSTR szProperty,
1259                                  LPWSTR szValue, LPDWORD pcchValue)
1260 {
1261     WCHAR squished_pc[GUID_SIZE];
1262     LPWSTR val = NULL;
1263     LPCWSTR package = NULL;
1264     HKEY props = NULL, prod;
1265     HKEY classes = NULL, managed;
1266     HKEY hkey = NULL;
1267     DWORD type;
1268     UINT r = ERROR_UNKNOWN_PRODUCT;
1269
1270     static const WCHAR five[] = {'5',0};
1271     static const WCHAR displayname[] = {
1272         'D','i','s','p','l','a','y','N','a','m','e',0};
1273     static const WCHAR displayversion[] = {
1274         'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0};
1275     static const WCHAR managed_local_package[] = {
1276         'M','a','n','a','g','e','d','L','o','c','a','l',
1277         'P','a','c','k','a','g','e',0};
1278
1279     TRACE("(%s, %s, %d, %s, %p, %p)\n", debugstr_w(szProductCode),
1280           debugstr_w(szUserSid), dwContext, debugstr_w(szProperty),
1281            szValue, pcchValue);
1282
1283     if (!szProductCode || !squash_guid(szProductCode, squished_pc))
1284         return ERROR_INVALID_PARAMETER;
1285
1286     if (szValue && !pcchValue)
1287         return ERROR_INVALID_PARAMETER;
1288
1289     if (dwContext != MSIINSTALLCONTEXT_USERUNMANAGED &&
1290         dwContext != MSIINSTALLCONTEXT_USERMANAGED &&
1291         dwContext != MSIINSTALLCONTEXT_MACHINE)
1292         return ERROR_INVALID_PARAMETER;
1293
1294     if (!szProperty || !*szProperty)
1295         return ERROR_INVALID_PARAMETER;
1296
1297     if (dwContext == MSIINSTALLCONTEXT_MACHINE && szUserSid)
1298         return ERROR_INVALID_PARAMETER;
1299
1300     /* FIXME: dwContext is provided, no need to search for it */
1301     MSIREG_OpenProductKey(szProductCode, NULL,MSIINSTALLCONTEXT_USERMANAGED,
1302                           &managed, FALSE);
1303     MSIREG_OpenProductKey(szProductCode, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
1304                           &prod, FALSE);
1305
1306     MSIREG_OpenInstallProps(szProductCode, dwContext, NULL, &props, FALSE);
1307
1308     if (dwContext == MSIINSTALLCONTEXT_USERUNMANAGED)
1309     {
1310         package = INSTALLPROPERTY_LOCALPACKAGEW;
1311
1312         if (!props && !prod)
1313             goto done;
1314     }
1315     else if (dwContext == MSIINSTALLCONTEXT_USERMANAGED)
1316     {
1317         package = managed_local_package;
1318
1319         if (!props && !managed)
1320             goto done;
1321     }
1322     else if (dwContext == MSIINSTALLCONTEXT_MACHINE)
1323     {
1324         package = INSTALLPROPERTY_LOCALPACKAGEW;
1325         MSIREG_OpenProductKey(szProductCode, NULL, dwContext, &classes, FALSE);
1326
1327         if (!props && !classes)
1328             goto done;
1329     }
1330
1331     if (!strcmpW( szProperty, INSTALLPROPERTY_HELPLINKW ) ||
1332         !strcmpW( szProperty, INSTALLPROPERTY_HELPTELEPHONEW ) ||
1333         !strcmpW( szProperty, INSTALLPROPERTY_INSTALLDATEW ) ||
1334         !strcmpW( szProperty, INSTALLPROPERTY_INSTALLEDPRODUCTNAMEW ) ||
1335         !strcmpW( szProperty, INSTALLPROPERTY_INSTALLLOCATIONW ) ||
1336         !strcmpW( szProperty, INSTALLPROPERTY_INSTALLSOURCEW ) ||
1337         !strcmpW( szProperty, INSTALLPROPERTY_LOCALPACKAGEW ) ||
1338         !strcmpW( szProperty, INSTALLPROPERTY_PUBLISHERW ) ||
1339         !strcmpW( szProperty, INSTALLPROPERTY_URLINFOABOUTW ) ||
1340         !strcmpW( szProperty, INSTALLPROPERTY_URLUPDATEINFOW ) ||
1341         !strcmpW( szProperty, INSTALLPROPERTY_VERSIONMINORW ) ||
1342         !strcmpW( szProperty, INSTALLPROPERTY_VERSIONMAJORW ) ||
1343         !strcmpW( szProperty, INSTALLPROPERTY_VERSIONSTRINGW ) ||
1344         !strcmpW( szProperty, INSTALLPROPERTY_PRODUCTIDW ) ||
1345         !strcmpW( szProperty, INSTALLPROPERTY_REGCOMPANYW ) ||
1346         !strcmpW( szProperty, INSTALLPROPERTY_REGOWNERW ) ||
1347         !strcmpW( szProperty, INSTALLPROPERTY_INSTANCETYPEW ))
1348     {
1349         val = msi_reg_get_value(props, package, &type);
1350         if (!val)
1351         {
1352             if (prod || classes)
1353                 r = ERROR_UNKNOWN_PROPERTY;
1354
1355             goto done;
1356         }
1357
1358         msi_free(val);
1359
1360         if (!strcmpW( szProperty, INSTALLPROPERTY_INSTALLEDPRODUCTNAMEW ))
1361             szProperty = displayname;
1362         else if (!strcmpW( szProperty, INSTALLPROPERTY_VERSIONSTRINGW ))
1363             szProperty = displayversion;
1364
1365         val = msi_reg_get_value(props, szProperty, &type);
1366         if (!val)
1367             val = strdupW(szEmpty);
1368
1369         r = msi_copy_outval(val, szValue, pcchValue);
1370     }
1371     else if (!strcmpW( szProperty, INSTALLPROPERTY_TRANSFORMSW ) ||
1372              !strcmpW( szProperty, INSTALLPROPERTY_LANGUAGEW ) ||
1373              !strcmpW( szProperty, INSTALLPROPERTY_PRODUCTNAMEW ) ||
1374              !strcmpW( szProperty, INSTALLPROPERTY_PACKAGECODEW ) ||
1375              !strcmpW( szProperty, INSTALLPROPERTY_VERSIONW ) ||
1376              !strcmpW( szProperty, INSTALLPROPERTY_PRODUCTICONW ) ||
1377              !strcmpW( szProperty, INSTALLPROPERTY_PACKAGENAMEW ) ||
1378              !strcmpW( szProperty, INSTALLPROPERTY_AUTHORIZED_LUA_APPW ))
1379     {
1380         if (!prod && !classes)
1381             goto done;
1382
1383         if (dwContext == MSIINSTALLCONTEXT_USERUNMANAGED)
1384             hkey = prod;
1385         else if (dwContext == MSIINSTALLCONTEXT_USERMANAGED)
1386             hkey = managed;
1387         else if (dwContext == MSIINSTALLCONTEXT_MACHINE)
1388             hkey = classes;
1389
1390         val = msi_reg_get_value(hkey, szProperty, &type);
1391         if (!val)
1392             val = strdupW(szEmpty);
1393
1394         r = msi_copy_outval(val, szValue, pcchValue);
1395     }
1396     else if (!strcmpW( szProperty, INSTALLPROPERTY_PRODUCTSTATEW ))
1397     {
1398         if (dwContext == MSIINSTALLCONTEXT_MACHINE)
1399         {
1400             if (props)
1401             {
1402                 val = msi_reg_get_value(props, package, &type);
1403                 if (!val)
1404                     goto done;
1405
1406                 msi_free(val);
1407                 val = strdupW(five);
1408             }
1409             else
1410                 val = strdupW(szOne);
1411
1412             r = msi_copy_outval(val, szValue, pcchValue);
1413             goto done;
1414         }
1415         else if (props && (val = msi_reg_get_value(props, package, &type)))
1416         {
1417             msi_free(val);
1418             val = strdupW(five);
1419             r = msi_copy_outval(val, szValue, pcchValue);
1420             goto done;
1421         }
1422
1423         if (prod || managed)
1424             val = strdupW(szOne);
1425         else
1426             goto done;
1427
1428         r = msi_copy_outval(val, szValue, pcchValue);
1429     }
1430     else if (!strcmpW( szProperty, INSTALLPROPERTY_ASSIGNMENTTYPEW ))
1431     {
1432         if (!prod && !classes)
1433             goto done;
1434
1435         /* FIXME */
1436         val = strdupW(szEmpty);
1437         r = msi_copy_outval(val, szValue, pcchValue);
1438     }
1439     else
1440         r = ERROR_UNKNOWN_PROPERTY;
1441
1442 done:
1443     RegCloseKey(props);
1444     RegCloseKey(prod);
1445     RegCloseKey(managed);
1446     RegCloseKey(classes);
1447     msi_free(val);
1448
1449     return r;
1450 }
1451
1452 UINT WINAPI MsiGetPatchInfoExA(LPCSTR szPatchCode, LPCSTR szProductCode,
1453                                LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext,
1454                                LPCSTR szProperty, LPSTR lpValue, DWORD *pcchValue)
1455 {
1456     LPWSTR patch = NULL, product = NULL, usersid = NULL;
1457     LPWSTR property = NULL, val = NULL;
1458     DWORD len;
1459     UINT r;
1460
1461     TRACE("(%s, %s, %s, %d, %s, %p, %p)\n", debugstr_a(szPatchCode),
1462           debugstr_a(szProductCode), debugstr_a(szUserSid), dwContext,
1463           debugstr_a(szProperty), lpValue, pcchValue);
1464
1465     if (lpValue && !pcchValue)
1466         return ERROR_INVALID_PARAMETER;
1467
1468     if (szPatchCode) patch = strdupAtoW(szPatchCode);
1469     if (szProductCode) product = strdupAtoW(szProductCode);
1470     if (szUserSid) usersid = strdupAtoW(szUserSid);
1471     if (szProperty) property = strdupAtoW(szProperty);
1472
1473     len = 0;
1474     r = MsiGetPatchInfoExW(patch, product, usersid, dwContext, property,
1475                            NULL, &len);
1476     if (r != ERROR_SUCCESS)
1477         goto done;
1478
1479     val = msi_alloc(++len * sizeof(WCHAR));
1480     if (!val)
1481     {
1482         r = ERROR_OUTOFMEMORY;
1483         goto done;
1484     }
1485
1486     r = MsiGetPatchInfoExW(patch, product, usersid, dwContext, property,
1487                            val, &len);
1488     if (r != ERROR_SUCCESS || !pcchValue)
1489         goto done;
1490
1491     if (lpValue)
1492         WideCharToMultiByte(CP_ACP, 0, val, -1, lpValue,
1493                             *pcchValue - 1, NULL, NULL);
1494
1495     len = lstrlenW(val);
1496     if ((*val && *pcchValue < len + 1) || !lpValue)
1497     {
1498         if (lpValue)
1499         {
1500             r = ERROR_MORE_DATA;
1501             lpValue[*pcchValue - 1] = '\0';
1502         }
1503
1504         *pcchValue = len * sizeof(WCHAR);
1505     }
1506     else
1507         *pcchValue = len;
1508
1509 done:
1510     msi_free(val);
1511     msi_free(patch);
1512     msi_free(product);
1513     msi_free(usersid);
1514     msi_free(property);
1515
1516     return r;
1517 }
1518
1519 UINT WINAPI MsiGetPatchInfoExW(LPCWSTR szPatchCode, LPCWSTR szProductCode,
1520                                LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext,
1521                                LPCWSTR szProperty, LPWSTR lpValue, DWORD *pcchValue)
1522 {
1523     WCHAR squished_pc[GUID_SIZE];
1524     WCHAR squished_patch[GUID_SIZE];
1525     HKEY udprod = 0, prod = 0, props = 0;
1526     HKEY patch = 0, patches = 0;
1527     HKEY udpatch = 0, datakey = 0;
1528     HKEY prodpatches = 0;
1529     LPWSTR val = NULL;
1530     UINT r = ERROR_UNKNOWN_PRODUCT;
1531     DWORD len;
1532     LONG res;
1533
1534     static const WCHAR szManagedPackage[] = {'M','a','n','a','g','e','d',
1535         'L','o','c','a','l','P','a','c','k','a','g','e',0};
1536
1537     TRACE("(%s, %s, %s, %d, %s, %p, %p)\n", debugstr_w(szPatchCode),
1538           debugstr_w(szProductCode), debugstr_w(szUserSid), dwContext,
1539           debugstr_w(szProperty), lpValue, pcchValue);
1540
1541     if (!szProductCode || !squash_guid(szProductCode, squished_pc))
1542         return ERROR_INVALID_PARAMETER;
1543
1544     if (!szPatchCode || !squash_guid(szPatchCode, squished_patch))
1545         return ERROR_INVALID_PARAMETER;
1546
1547     if (!szProperty)
1548         return ERROR_INVALID_PARAMETER;
1549
1550     if (lpValue && !pcchValue)
1551         return ERROR_INVALID_PARAMETER;
1552
1553     if (dwContext != MSIINSTALLCONTEXT_USERMANAGED &&
1554         dwContext != MSIINSTALLCONTEXT_USERUNMANAGED &&
1555         dwContext != MSIINSTALLCONTEXT_MACHINE)
1556         return ERROR_INVALID_PARAMETER;
1557
1558     if (dwContext == MSIINSTALLCONTEXT_MACHINE && szUserSid)
1559         return ERROR_INVALID_PARAMETER;
1560
1561     if (szUserSid && !strcmpW( szUserSid, szLocalSid ))
1562         return ERROR_INVALID_PARAMETER;
1563
1564     if (MSIREG_OpenUserDataProductKey(szProductCode, dwContext, NULL,
1565                                       &udprod, FALSE) != ERROR_SUCCESS)
1566         goto done;
1567
1568     if (MSIREG_OpenInstallProps(szProductCode, dwContext, NULL,
1569                                 &props, FALSE) != ERROR_SUCCESS)
1570         goto done;
1571
1572     r = ERROR_UNKNOWN_PATCH;
1573
1574     res = RegOpenKeyExW(udprod, szPatches, 0, KEY_READ, &patches);
1575     if (res != ERROR_SUCCESS)
1576         goto done;
1577
1578     res = RegOpenKeyExW(patches, squished_patch, 0, KEY_READ, &patch);
1579     if (res != ERROR_SUCCESS)
1580         goto done;
1581
1582     if (!strcmpW( szProperty, INSTALLPROPERTY_TRANSFORMSW ))
1583     {
1584         if (MSIREG_OpenProductKey(szProductCode, NULL, dwContext,
1585                                   &prod, FALSE) != ERROR_SUCCESS)
1586             goto done;
1587
1588         res = RegOpenKeyExW(prod, szPatches, 0, KEY_ALL_ACCESS, &prodpatches);
1589         if (res != ERROR_SUCCESS)
1590             goto done;
1591
1592         datakey = prodpatches;
1593         szProperty = squished_patch;
1594     }
1595     else
1596     {
1597         if (MSIREG_OpenUserDataPatchKey(szPatchCode, dwContext,
1598                                         &udpatch, FALSE) != ERROR_SUCCESS)
1599             goto done;
1600
1601         if (!strcmpW( szProperty, INSTALLPROPERTY_LOCALPACKAGEW ))
1602         {
1603             if (dwContext == MSIINSTALLCONTEXT_USERMANAGED)
1604                 szProperty = szManagedPackage;
1605             datakey = udpatch;
1606         }
1607         else if (!strcmpW( szProperty, INSTALLPROPERTY_INSTALLDATEW ))
1608         {
1609             datakey = patch;
1610             szProperty = szInstalled;
1611         }
1612         else if (!strcmpW( szProperty, INSTALLPROPERTY_LOCALPACKAGEW ))
1613         {
1614             datakey = udpatch;
1615         }
1616         else if (!strcmpW( szProperty, INSTALLPROPERTY_UNINSTALLABLEW ) ||
1617                  !strcmpW( szProperty, INSTALLPROPERTY_PATCHSTATEW ) ||
1618                  !strcmpW( szProperty, INSTALLPROPERTY_DISPLAYNAMEW ) ||
1619                  !strcmpW( szProperty, INSTALLPROPERTY_MOREINFOURLW ))
1620         {
1621             datakey = patch;
1622         }
1623         else
1624         {
1625             r = ERROR_UNKNOWN_PROPERTY;
1626             goto done;
1627         }
1628     }
1629
1630     val = msi_reg_get_val_str(datakey, szProperty);
1631     if (!val)
1632         val = strdupW(szEmpty);
1633
1634     r = ERROR_SUCCESS;
1635
1636     if (!pcchValue)
1637         goto done;
1638
1639     if (lpValue)
1640         lstrcpynW(lpValue, val, *pcchValue);
1641
1642     len = lstrlenW(val);
1643     if ((*val && *pcchValue < len + 1) || !lpValue)
1644     {
1645         if (lpValue)
1646             r = ERROR_MORE_DATA;
1647
1648         *pcchValue = len * sizeof(WCHAR);
1649     }
1650
1651     *pcchValue = len;
1652
1653 done:
1654     msi_free(val);
1655     RegCloseKey(prodpatches);
1656     RegCloseKey(prod);
1657     RegCloseKey(patch);
1658     RegCloseKey(patches);
1659     RegCloseKey(udpatch);
1660     RegCloseKey(props);
1661     RegCloseKey(udprod);
1662
1663     return r;
1664 }
1665
1666 UINT WINAPI MsiGetPatchInfoA( LPCSTR patch, LPCSTR attr, LPSTR buffer, LPDWORD buflen )
1667 {
1668     UINT r = ERROR_OUTOFMEMORY;
1669     DWORD size;
1670     LPWSTR patchW = NULL, attrW = NULL, bufferW = NULL;
1671
1672     TRACE("%s %s %p %p\n", debugstr_a(patch), debugstr_a(attr), buffer, buflen);
1673
1674     if (!patch || !attr)
1675         return ERROR_INVALID_PARAMETER;
1676
1677     if (!(patchW = strdupAtoW( patch )))
1678         goto done;
1679
1680     if (!(attrW = strdupAtoW( attr )))
1681         goto done;
1682
1683     size = 0;
1684     r = MsiGetPatchInfoW( patchW, attrW, NULL, &size );
1685     if (r != ERROR_SUCCESS)
1686         goto done;
1687
1688     size++;
1689     if (!(bufferW = msi_alloc( size * sizeof(WCHAR) )))
1690     {
1691         r = ERROR_OUTOFMEMORY;
1692         goto done;
1693     }
1694
1695     r = MsiGetPatchInfoW( patchW, attrW, bufferW, &size );
1696     if (r == ERROR_SUCCESS)
1697     {
1698         int len = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );
1699         if (len > *buflen)
1700             r = ERROR_MORE_DATA;
1701         else if (buffer)
1702             WideCharToMultiByte( CP_ACP, 0, bufferW, -1, buffer, *buflen, NULL, NULL );
1703
1704         *buflen = len - 1;
1705     }
1706
1707 done:
1708     msi_free( patchW );
1709     msi_free( attrW );
1710     msi_free( bufferW );
1711     return r;
1712 }
1713
1714 UINT WINAPI MsiGetPatchInfoW( LPCWSTR patch, LPCWSTR attr, LPWSTR buffer, LPDWORD buflen )
1715 {
1716     UINT r;
1717     WCHAR product[GUID_SIZE];
1718     DWORD index;
1719
1720     TRACE("%s %s %p %p\n", debugstr_w(patch), debugstr_w(attr), buffer, buflen);
1721
1722     if (!patch || !attr)
1723         return ERROR_INVALID_PARAMETER;
1724
1725     if (strcmpW( INSTALLPROPERTY_LOCALPACKAGEW, attr ))
1726         return ERROR_UNKNOWN_PROPERTY;
1727
1728     index = 0;
1729     while (1)
1730     {
1731         r = MsiEnumProductsW( index, product );
1732         if (r != ERROR_SUCCESS)
1733             break;
1734
1735         r = MsiGetPatchInfoExW( patch, product, NULL, MSIINSTALLCONTEXT_USERMANAGED, attr, buffer, buflen );
1736         if (r == ERROR_SUCCESS || r == ERROR_MORE_DATA)
1737             return r;
1738
1739         r = MsiGetPatchInfoExW( patch, product, NULL, MSIINSTALLCONTEXT_USERUNMANAGED, attr, buffer, buflen );
1740         if (r == ERROR_SUCCESS || r == ERROR_MORE_DATA)
1741             return r;
1742
1743         r = MsiGetPatchInfoExW( patch, product, NULL, MSIINSTALLCONTEXT_MACHINE, attr, buffer, buflen );
1744         if (r == ERROR_SUCCESS || r == ERROR_MORE_DATA)
1745             return r;
1746
1747         index++;
1748     }
1749
1750     return ERROR_UNKNOWN_PRODUCT;
1751 }
1752
1753 UINT WINAPI MsiEnableLogA(DWORD dwLogMode, LPCSTR szLogFile, DWORD attributes)
1754 {
1755     LPWSTR szwLogFile = NULL;
1756     UINT r;
1757
1758     TRACE("%08x %s %08x\n", dwLogMode, debugstr_a(szLogFile), attributes);
1759
1760     if( szLogFile )
1761     {
1762         szwLogFile = strdupAtoW( szLogFile );
1763         if( !szwLogFile )
1764             return ERROR_OUTOFMEMORY;
1765     }
1766     r = MsiEnableLogW( dwLogMode, szwLogFile, attributes );
1767     msi_free( szwLogFile );
1768     return r;
1769 }
1770
1771 UINT WINAPI MsiEnableLogW(DWORD dwLogMode, LPCWSTR szLogFile, DWORD attributes)
1772 {
1773     TRACE("%08x %s %08x\n", dwLogMode, debugstr_w(szLogFile), attributes);
1774
1775     msi_free(gszLogFile);
1776     gszLogFile = NULL;
1777     if (szLogFile)
1778     {
1779         HANDLE file;
1780
1781         if (!(attributes & INSTALLLOGATTRIBUTES_APPEND))
1782             DeleteFileW(szLogFile);
1783         file = CreateFileW(szLogFile, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_ALWAYS,
1784                            FILE_ATTRIBUTE_NORMAL, NULL);
1785         if (file != INVALID_HANDLE_VALUE)
1786         {
1787             gszLogFile = strdupW(szLogFile);
1788             CloseHandle(file);
1789         }
1790         else
1791             ERR("Unable to enable log %s (%u)\n", debugstr_w(szLogFile), GetLastError());
1792     }
1793
1794     return ERROR_SUCCESS;
1795 }
1796
1797 UINT WINAPI MsiEnumComponentCostsW(MSIHANDLE hInstall, LPCWSTR szComponent,
1798                                    DWORD dwIndex, INSTALLSTATE iState,
1799                                    LPWSTR lpDriveBuf, DWORD *pcchDriveBuf,
1800                                    int *piCost, int *pTempCost)
1801 {
1802     FIXME("(%d, %s, %d, %d, %p, %p, %p %p): stub!\n", hInstall,
1803           debugstr_w(szComponent), dwIndex, iState, lpDriveBuf,
1804           pcchDriveBuf, piCost, pTempCost);
1805
1806     return ERROR_NO_MORE_ITEMS;
1807 }
1808
1809 UINT WINAPI MsiQueryComponentStateA(LPCSTR szProductCode,
1810                                     LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext,
1811                                     LPCSTR szComponent, INSTALLSTATE *pdwState)
1812 {
1813     LPWSTR prodcode = NULL, usersid = NULL, comp = NULL;
1814     UINT r;
1815
1816     TRACE("(%s, %s, %d, %s, %p)\n", debugstr_a(szProductCode),
1817           debugstr_a(szUserSid), dwContext, debugstr_a(szComponent), pdwState);
1818
1819     if (szProductCode && !(prodcode = strdupAtoW(szProductCode)))
1820         return ERROR_OUTOFMEMORY;
1821
1822     if (szUserSid && !(usersid = strdupAtoW(szUserSid)))
1823             return ERROR_OUTOFMEMORY;
1824
1825     if (szComponent && !(comp = strdupAtoW(szComponent)))
1826             return ERROR_OUTOFMEMORY;
1827
1828     r = MsiQueryComponentStateW(prodcode, usersid, dwContext, comp, pdwState);
1829
1830     msi_free(prodcode);
1831     msi_free(usersid);
1832     msi_free(comp);
1833
1834     return r;
1835 }
1836
1837 static BOOL msi_comp_find_prod_key(LPCWSTR prodcode, MSIINSTALLCONTEXT context)
1838 {
1839     UINT r;
1840     HKEY hkey;
1841
1842     r = MSIREG_OpenProductKey(prodcode, NULL, context, &hkey, FALSE);
1843     RegCloseKey(hkey);
1844     return (r == ERROR_SUCCESS);
1845 }
1846
1847 static BOOL msi_comp_find_package(LPCWSTR prodcode, MSIINSTALLCONTEXT context)
1848 {
1849     LPCWSTR package;
1850     HKEY hkey;
1851     DWORD sz;
1852     LONG res;
1853     UINT r;
1854
1855     static const WCHAR local_package[] = {'L','o','c','a','l','P','a','c','k','a','g','e',0};
1856     static const WCHAR managed_local_package[] = {
1857         'M','a','n','a','g','e','d','L','o','c','a','l','P','a','c','k','a','g','e',0
1858     };
1859
1860     r = MSIREG_OpenInstallProps(prodcode, context, NULL, &hkey, FALSE);
1861     if (r != ERROR_SUCCESS)
1862         return FALSE;
1863
1864     if (context == MSIINSTALLCONTEXT_USERMANAGED)
1865         package = managed_local_package;
1866     else
1867         package = local_package;
1868
1869     sz = 0;
1870     res = RegQueryValueExW(hkey, package, NULL, NULL, NULL, &sz);
1871     RegCloseKey(hkey);
1872
1873     return (res == ERROR_SUCCESS);
1874 }
1875
1876 static BOOL msi_comp_find_prodcode(LPWSTR squished_pc,
1877                                    MSIINSTALLCONTEXT context,
1878                                    LPCWSTR comp, LPWSTR val, DWORD *sz)
1879 {
1880     HKEY hkey;
1881     LONG res;
1882     UINT r;
1883
1884     if (context == MSIINSTALLCONTEXT_MACHINE)
1885         r = MSIREG_OpenUserDataComponentKey(comp, szLocalSid, &hkey, FALSE);
1886     else
1887         r = MSIREG_OpenUserDataComponentKey(comp, NULL, &hkey, FALSE);
1888
1889     if (r != ERROR_SUCCESS)
1890         return FALSE;
1891
1892     res = RegQueryValueExW(hkey, squished_pc, NULL, NULL, (BYTE *)val, sz);
1893     if (res != ERROR_SUCCESS)
1894         return FALSE;
1895
1896     RegCloseKey(hkey);
1897     return TRUE;
1898 }
1899
1900 UINT WINAPI MsiQueryComponentStateW(LPCWSTR szProductCode,
1901                                     LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext,
1902                                     LPCWSTR szComponent, INSTALLSTATE *pdwState)
1903 {
1904     WCHAR squished_pc[GUID_SIZE];
1905     WCHAR val[MAX_PATH];
1906     BOOL found;
1907     DWORD sz;
1908
1909     TRACE("(%s, %s, %d, %s, %p)\n", debugstr_w(szProductCode),
1910           debugstr_w(szUserSid), dwContext, debugstr_w(szComponent), pdwState);
1911
1912     if (!pdwState || !szComponent)
1913         return ERROR_INVALID_PARAMETER;
1914
1915     if (!szProductCode || !*szProductCode || lstrlenW(szProductCode) != GUID_SIZE - 1)
1916         return ERROR_INVALID_PARAMETER;
1917
1918     if (!squash_guid(szProductCode, squished_pc))
1919         return ERROR_INVALID_PARAMETER;
1920
1921     found = msi_comp_find_prod_key(szProductCode, dwContext);
1922
1923     if (!msi_comp_find_package(szProductCode, dwContext))
1924     {
1925         if (found)
1926         {
1927             *pdwState = INSTALLSTATE_UNKNOWN;
1928             return ERROR_UNKNOWN_COMPONENT;
1929         }
1930
1931         return ERROR_UNKNOWN_PRODUCT;
1932     }
1933
1934     *pdwState = INSTALLSTATE_UNKNOWN;
1935
1936     sz = MAX_PATH;
1937     if (!msi_comp_find_prodcode(squished_pc, dwContext, szComponent, val, &sz))
1938         return ERROR_UNKNOWN_COMPONENT;
1939
1940     if (sz == 0)
1941         *pdwState = INSTALLSTATE_NOTUSED;
1942     else
1943     {
1944         if (lstrlenW(val) > 2 &&
1945             val[0] >= '0' && val[0] <= '9' && val[1] >= '0' && val[1] <= '9')
1946         {
1947             *pdwState = INSTALLSTATE_SOURCE;
1948         }
1949         else
1950             *pdwState = INSTALLSTATE_LOCAL;
1951     }
1952
1953     TRACE("-> %d\n", *pdwState);
1954     return ERROR_SUCCESS;
1955 }
1956
1957 INSTALLSTATE WINAPI MsiQueryProductStateA(LPCSTR szProduct)
1958 {
1959     LPWSTR szwProduct = NULL;
1960     INSTALLSTATE r;
1961
1962     if( szProduct )
1963     {
1964          szwProduct = strdupAtoW( szProduct );
1965          if( !szwProduct )
1966              return ERROR_OUTOFMEMORY;
1967     }
1968     r = MsiQueryProductStateW( szwProduct );
1969     msi_free( szwProduct );
1970     return r;
1971 }
1972
1973 INSTALLSTATE WINAPI MsiQueryProductStateW(LPCWSTR szProduct)
1974 {
1975     MSIINSTALLCONTEXT context = MSIINSTALLCONTEXT_USERUNMANAGED;
1976     INSTALLSTATE state = INSTALLSTATE_ADVERTISED;
1977     HKEY prodkey = 0, userdata = 0;
1978     DWORD val;
1979     UINT r;
1980
1981     static const WCHAR szWindowsInstaller[] = {
1982         'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
1983
1984     TRACE("%s\n", debugstr_w(szProduct));
1985
1986     if (!szProduct || !*szProduct)
1987         return INSTALLSTATE_INVALIDARG;
1988
1989     if (lstrlenW(szProduct) != GUID_SIZE - 1)
1990         return INSTALLSTATE_INVALIDARG;
1991
1992     if (szProduct[0] != '{' || szProduct[37] != '}')
1993         return INSTALLSTATE_UNKNOWN;
1994
1995     SetLastError( ERROR_SUCCESS );
1996
1997     if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
1998                               &prodkey, FALSE) != ERROR_SUCCESS &&
1999         MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2000                               &prodkey, FALSE) != ERROR_SUCCESS &&
2001         MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
2002                               &prodkey, FALSE) == ERROR_SUCCESS)
2003     {
2004         context = MSIINSTALLCONTEXT_MACHINE;
2005     }
2006
2007     r = MSIREG_OpenInstallProps(szProduct, context, NULL, &userdata, FALSE);
2008     if (r != ERROR_SUCCESS)
2009         goto done;
2010
2011     if (!msi_reg_get_val_dword(userdata, szWindowsInstaller, &val))
2012         goto done;
2013
2014     if (val)
2015         state = INSTALLSTATE_DEFAULT;
2016     else
2017         state = INSTALLSTATE_UNKNOWN;
2018
2019 done:
2020     if (!prodkey)
2021     {
2022         state = INSTALLSTATE_UNKNOWN;
2023
2024         if (userdata)
2025             state = INSTALLSTATE_ABSENT;
2026     }
2027
2028     RegCloseKey(prodkey);
2029     RegCloseKey(userdata);
2030     TRACE("-> %d\n", state);
2031     return state;
2032 }
2033
2034 INSTALLUILEVEL WINAPI MsiSetInternalUI(INSTALLUILEVEL dwUILevel, HWND *phWnd)
2035 {
2036     INSTALLUILEVEL old = gUILevel;
2037     HWND oldwnd = gUIhwnd;
2038
2039     TRACE("%08x %p\n", dwUILevel, phWnd);
2040
2041     gUILevel = dwUILevel;
2042     if (phWnd)
2043     {
2044         gUIhwnd = *phWnd;
2045         *phWnd = oldwnd;
2046     }
2047     return old;
2048 }
2049
2050 INSTALLUI_HANDLERA WINAPI MsiSetExternalUIA(INSTALLUI_HANDLERA puiHandler,
2051                                   DWORD dwMessageFilter, LPVOID pvContext)
2052 {
2053     INSTALLUI_HANDLERA prev = gUIHandlerA;
2054
2055     TRACE("%p %08x %p\n", puiHandler, dwMessageFilter, pvContext);
2056
2057     gUIHandlerA = puiHandler;
2058     gUIHandlerW = NULL;
2059     gUIFilter   = dwMessageFilter;
2060     gUIContext  = pvContext;
2061
2062     return prev;
2063 }
2064
2065 INSTALLUI_HANDLERW WINAPI MsiSetExternalUIW(INSTALLUI_HANDLERW puiHandler,
2066                                   DWORD dwMessageFilter, LPVOID pvContext)
2067 {
2068     INSTALLUI_HANDLERW prev = gUIHandlerW;
2069
2070     TRACE("%p %08x %p\n", puiHandler, dwMessageFilter, pvContext);
2071
2072     gUIHandlerA = NULL;
2073     gUIHandlerW = puiHandler;
2074     gUIFilter   = dwMessageFilter;
2075     gUIContext  = pvContext;
2076
2077     return prev;
2078 }
2079
2080 /******************************************************************
2081  *  MsiLoadStringW            [MSI.@]
2082  *
2083  * Loads a string from MSI's string resources.
2084  *
2085  * PARAMS
2086  *
2087  *   handle        [I]  only -1 is handled currently
2088  *   id            [I]  id of the string to be loaded
2089  *   lpBuffer      [O]  buffer for the string to be written to
2090  *   nBufferMax    [I]  maximum size of the buffer in characters
2091  *   lang          [I]  the preferred language for the string
2092  *
2093  * RETURNS
2094  *
2095  *   If successful, this function returns the language id of the string loaded
2096  *   If the function fails, the function returns zero.
2097  *
2098  * NOTES
2099  *
2100  *   The type of the first parameter is unknown.  LoadString's prototype
2101  *  suggests that it might be a module handle.  I have made it an MSI handle
2102  *  for starters, as -1 is an invalid MSI handle, but not an invalid module
2103  *  handle.  Maybe strings can be stored in an MSI database somehow.
2104  */
2105 LANGID WINAPI MsiLoadStringW( MSIHANDLE handle, UINT id, LPWSTR lpBuffer,
2106                 int nBufferMax, LANGID lang )
2107 {
2108     HRSRC hres;
2109     HGLOBAL hResData;
2110     LPWSTR p;
2111     DWORD i, len;
2112
2113     TRACE("%d %u %p %d %d\n", handle, id, lpBuffer, nBufferMax, lang);
2114
2115     if( handle != -1 )
2116         FIXME("don't know how to deal with handle = %08x\n", handle);
2117
2118     if( !lang )
2119         lang = GetUserDefaultLangID();
2120
2121     hres = FindResourceExW( msi_hInstance, (LPCWSTR) RT_STRING,
2122                             (LPWSTR)1, lang );
2123     if( !hres )
2124         return 0;
2125     hResData = LoadResource( msi_hInstance, hres );
2126     if( !hResData )
2127         return 0;
2128     p = LockResource( hResData );
2129     if( !p )
2130         return 0;
2131
2132     for (i = 0; i < (id&0xf); i++)
2133         p += *p + 1;
2134     len = *p;
2135
2136     if( nBufferMax <= len )
2137         return 0;
2138
2139     memcpy( lpBuffer, p+1, len * sizeof(WCHAR));
2140     lpBuffer[ len ] = 0;
2141
2142     TRACE("found -> %s\n", debugstr_w(lpBuffer));
2143
2144     return lang;
2145 }
2146
2147 LANGID WINAPI MsiLoadStringA( MSIHANDLE handle, UINT id, LPSTR lpBuffer,
2148                 int nBufferMax, LANGID lang )
2149 {
2150     LPWSTR bufW;
2151     LANGID r;
2152     INT len;
2153
2154     bufW = msi_alloc(nBufferMax*sizeof(WCHAR));
2155     r = MsiLoadStringW(handle, id, bufW, nBufferMax, lang);
2156     if( r )
2157     {
2158         len = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL, NULL );
2159         if( len <= nBufferMax )
2160             WideCharToMultiByte( CP_ACP, 0, bufW, -1,
2161                                  lpBuffer, nBufferMax, NULL, NULL );
2162         else
2163             r = 0;
2164     }
2165     msi_free(bufW);
2166     return r;
2167 }
2168
2169 INSTALLSTATE WINAPI MsiLocateComponentA(LPCSTR szComponent, LPSTR lpPathBuf,
2170                 LPDWORD pcchBuf)
2171 {
2172     char szProduct[GUID_SIZE];
2173
2174     TRACE("%s %p %p\n", debugstr_a(szComponent), lpPathBuf, pcchBuf);
2175
2176     if (!szComponent || !pcchBuf)
2177         return INSTALLSTATE_INVALIDARG;
2178
2179     if (MsiGetProductCodeA( szComponent, szProduct ) != ERROR_SUCCESS)
2180         return INSTALLSTATE_UNKNOWN;
2181
2182     return MsiGetComponentPathA( szProduct, szComponent, lpPathBuf, pcchBuf );
2183 }
2184
2185 INSTALLSTATE WINAPI MsiLocateComponentW(LPCWSTR szComponent, LPWSTR lpPathBuf,
2186                 LPDWORD pcchBuf)
2187 {
2188     WCHAR szProduct[GUID_SIZE];
2189
2190     TRACE("%s %p %p\n", debugstr_w(szComponent), lpPathBuf, pcchBuf);
2191
2192     if (!szComponent || !pcchBuf)
2193         return INSTALLSTATE_INVALIDARG;
2194
2195     if (MsiGetProductCodeW( szComponent, szProduct ) != ERROR_SUCCESS)
2196         return INSTALLSTATE_UNKNOWN;
2197
2198     return MsiGetComponentPathW( szProduct, szComponent, lpPathBuf, pcchBuf );
2199 }
2200
2201 UINT WINAPI MsiMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,
2202                 WORD wLanguageId, DWORD f)
2203 {
2204     FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_a(lpText), debugstr_a(lpCaption),
2205           uType, wLanguageId, f);
2206     return MessageBoxExA(hWnd,lpText,lpCaption,uType,wLanguageId);
2207 }
2208
2209 UINT WINAPI MsiMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,
2210                 WORD wLanguageId, DWORD f)
2211 {
2212     FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_w(lpText), debugstr_w(lpCaption),
2213           uType, wLanguageId, f);
2214     return MessageBoxExW(hWnd,lpText,lpCaption,uType,wLanguageId);
2215 }
2216
2217 UINT WINAPI MsiMessageBoxExA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,
2218                 DWORD unknown, WORD wLanguageId, DWORD f)
2219 {
2220     FIXME("(%p, %s, %s, %u, 0x%08x, 0x%08x, 0x%08x): semi-stub\n", hWnd, debugstr_a(lpText),
2221             debugstr_a(lpCaption), uType, unknown, wLanguageId, f);
2222     return MessageBoxExA(hWnd, lpText, lpCaption, uType, wLanguageId);
2223 }
2224
2225 UINT WINAPI MsiMessageBoxExW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,
2226                 DWORD unknown, WORD wLanguageId, DWORD f)
2227 {
2228     FIXME("(%p, %s, %s, %u, 0x%08x, 0x%08x, 0x%08x): semi-stub\n", hWnd, debugstr_w(lpText),
2229             debugstr_w(lpCaption), uType, unknown, wLanguageId, f);
2230     return MessageBoxExW(hWnd, lpText, lpCaption, uType, wLanguageId);
2231 }
2232
2233 UINT WINAPI MsiProvideAssemblyA( LPCSTR szAssemblyName, LPCSTR szAppContext,
2234                 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPSTR lpPathBuf,
2235                 LPDWORD pcchPathBuf )
2236 {
2237     FIXME("%s %s %08x %08x %p %p\n", debugstr_a(szAssemblyName),
2238           debugstr_a(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
2239           pcchPathBuf);
2240     return ERROR_CALL_NOT_IMPLEMENTED;
2241 }
2242
2243 UINT WINAPI MsiProvideAssemblyW( LPCWSTR szAssemblyName, LPCWSTR szAppContext,
2244                 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPWSTR lpPathBuf,
2245                 LPDWORD pcchPathBuf )
2246 {
2247     FIXME("%s %s %08x %08x %p %p\n", debugstr_w(szAssemblyName),
2248           debugstr_w(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
2249           pcchPathBuf);
2250     return ERROR_CALL_NOT_IMPLEMENTED;
2251 }
2252
2253 UINT WINAPI MsiProvideComponentFromDescriptorA( LPCSTR szDescriptor,
2254                 LPSTR szPath, LPDWORD pcchPath, LPDWORD pcchArgs )
2255 {
2256     FIXME("%s %p %p %p\n", debugstr_a(szDescriptor), szPath, pcchPath, pcchArgs );
2257     return ERROR_CALL_NOT_IMPLEMENTED;
2258 }
2259
2260 UINT WINAPI MsiProvideComponentFromDescriptorW( LPCWSTR szDescriptor,
2261                 LPWSTR szPath, LPDWORD pcchPath, LPDWORD pcchArgs )
2262 {
2263     FIXME("%s %p %p %p\n", debugstr_w(szDescriptor), szPath, pcchPath, pcchArgs );
2264     return ERROR_CALL_NOT_IMPLEMENTED;
2265 }
2266
2267 HRESULT WINAPI MsiGetFileSignatureInformationA( LPCSTR szSignedObjectPath,
2268                 DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, LPBYTE pbHashData,
2269                 LPDWORD pcbHashData)
2270 {
2271     FIXME("%s %08x %p %p %p\n", debugstr_a(szSignedObjectPath), dwFlags,
2272           ppcCertContext, pbHashData, pcbHashData);
2273     return ERROR_CALL_NOT_IMPLEMENTED;
2274 }
2275
2276 HRESULT WINAPI MsiGetFileSignatureInformationW( LPCWSTR szSignedObjectPath,
2277                 DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, LPBYTE pbHashData,
2278                 LPDWORD pcbHashData)
2279 {
2280     FIXME("%s %08x %p %p %p\n", debugstr_w(szSignedObjectPath), dwFlags,
2281           ppcCertContext, pbHashData, pcbHashData);
2282     return ERROR_CALL_NOT_IMPLEMENTED;
2283 }
2284
2285 /******************************************************************
2286  * MsiGetProductPropertyA      [MSI.@]
2287  */
2288 UINT WINAPI MsiGetProductPropertyA(MSIHANDLE hProduct, LPCSTR szProperty,
2289                                    LPSTR szValue, LPDWORD pccbValue)
2290 {
2291     LPWSTR prop = NULL, val = NULL;
2292     DWORD len;
2293     UINT r;
2294
2295     TRACE("(%d, %s, %p, %p)\n", hProduct, debugstr_a(szProperty),
2296           szValue, pccbValue);
2297
2298     if (szValue && !pccbValue)
2299         return ERROR_INVALID_PARAMETER;
2300
2301     if (szProperty) prop = strdupAtoW(szProperty);
2302
2303     len = 0;
2304     r = MsiGetProductPropertyW(hProduct, prop, NULL, &len);
2305     if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
2306         goto done;
2307
2308     if (r == ERROR_SUCCESS)
2309     {
2310         if (szValue) *szValue = '\0';
2311         if (pccbValue) *pccbValue = 0;
2312         goto done;
2313     }
2314
2315     val = msi_alloc(++len * sizeof(WCHAR));
2316     if (!val)
2317     {
2318         r = ERROR_OUTOFMEMORY;
2319         goto done;
2320     }
2321
2322     r = MsiGetProductPropertyW(hProduct, prop, val, &len);
2323     if (r != ERROR_SUCCESS)
2324         goto done;
2325
2326     len = WideCharToMultiByte(CP_ACP, 0, val, -1, NULL, 0, NULL, NULL);
2327
2328     if (szValue)
2329         WideCharToMultiByte(CP_ACP, 0, val, -1, szValue,
2330                             *pccbValue, NULL, NULL);
2331
2332     if (pccbValue)
2333     {
2334         if (len > *pccbValue)
2335             r = ERROR_MORE_DATA;
2336
2337         *pccbValue = len - 1;
2338     }
2339
2340 done:
2341     msi_free(prop);
2342     msi_free(val);
2343
2344     return r;
2345 }
2346
2347 /******************************************************************
2348  * MsiGetProductPropertyW      [MSI.@]
2349  */
2350 UINT WINAPI MsiGetProductPropertyW(MSIHANDLE hProduct, LPCWSTR szProperty,
2351                                    LPWSTR szValue, LPDWORD pccbValue)
2352 {
2353     MSIPACKAGE *package;
2354     MSIQUERY *view = NULL;
2355     MSIRECORD *rec = NULL;
2356     LPCWSTR val;
2357     UINT r;
2358
2359     static const WCHAR query[] = {
2360        'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2361        '`','P','r','o','p','e','r','t','y','`',' ','W','H','E','R','E',' ',
2362        '`','P','r','o','p','e','r','t','y','`','=','\'','%','s','\'',0};
2363
2364     TRACE("(%d, %s, %p, %p)\n", hProduct, debugstr_w(szProperty),
2365           szValue, pccbValue);
2366
2367     if (!szProperty)
2368         return ERROR_INVALID_PARAMETER;
2369
2370     if (szValue && !pccbValue)
2371         return ERROR_INVALID_PARAMETER;
2372
2373     package = msihandle2msiinfo(hProduct, MSIHANDLETYPE_PACKAGE);
2374     if (!package)
2375         return ERROR_INVALID_HANDLE;
2376
2377     r = MSI_OpenQuery(package->db, &view, query, szProperty);
2378     if (r != ERROR_SUCCESS)
2379         goto done;
2380
2381     r = MSI_ViewExecute(view, 0);
2382     if (r != ERROR_SUCCESS)
2383         goto done;
2384
2385     r = MSI_ViewFetch(view, &rec);
2386     if (r != ERROR_SUCCESS)
2387         goto done;
2388
2389     val = MSI_RecordGetString(rec, 2);
2390     if (!val)
2391         goto done;
2392
2393     if (lstrlenW(val) >= *pccbValue)
2394     {
2395         lstrcpynW(szValue, val, *pccbValue);
2396         *pccbValue = lstrlenW(val);
2397         r = ERROR_MORE_DATA;
2398     }
2399     else
2400     {
2401         lstrcpyW(szValue, val);
2402         *pccbValue = lstrlenW(val);
2403         r = ERROR_SUCCESS;
2404     }
2405
2406 done:
2407     if (view)
2408     {
2409         MSI_ViewClose(view);
2410         msiobj_release(&view->hdr);
2411         if (rec) msiobj_release(&rec->hdr);
2412     }
2413
2414     if (!rec)
2415     {
2416         if (szValue) *szValue = '\0';
2417         if (pccbValue) *pccbValue = 0;
2418         r = ERROR_SUCCESS;
2419     }
2420
2421     msiobj_release(&package->hdr);
2422     return r;
2423 }
2424
2425 UINT WINAPI MsiVerifyPackageA( LPCSTR szPackage )
2426 {
2427     UINT r;
2428     LPWSTR szPack = NULL;
2429
2430     TRACE("%s\n", debugstr_a(szPackage) );
2431
2432     if( szPackage )
2433     {
2434         szPack = strdupAtoW( szPackage );
2435         if( !szPack )
2436             return ERROR_OUTOFMEMORY;
2437     }
2438
2439     r = MsiVerifyPackageW( szPack );
2440
2441     msi_free( szPack );
2442
2443     return r;
2444 }
2445
2446 UINT WINAPI MsiVerifyPackageW( LPCWSTR szPackage )
2447 {
2448     MSIHANDLE handle;
2449     UINT r;
2450
2451     TRACE("%s\n", debugstr_w(szPackage) );
2452
2453     r = MsiOpenDatabaseW( szPackage, MSIDBOPEN_READONLY, &handle );
2454     MsiCloseHandle( handle );
2455
2456     return r;
2457 }
2458
2459 static INSTALLSTATE MSI_GetComponentPath(LPCWSTR szProduct, LPCWSTR szComponent,
2460                                          awstring* lpPathBuf, LPDWORD pcchBuf)
2461 {
2462     WCHAR squished_pc[GUID_SIZE];
2463     WCHAR squished_comp[GUID_SIZE];
2464     HKEY hkey;
2465     LPWSTR path = NULL;
2466     INSTALLSTATE state;
2467     DWORD version;
2468
2469     static const WCHAR wininstaller[] = {
2470         'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
2471
2472     TRACE("%s %s %p %p\n", debugstr_w(szProduct),
2473            debugstr_w(szComponent), lpPathBuf->str.w, pcchBuf);
2474
2475     if (!szProduct || !szComponent)
2476         return INSTALLSTATE_INVALIDARG;
2477
2478     if (lpPathBuf->str.w && !pcchBuf)
2479         return INSTALLSTATE_INVALIDARG;
2480
2481     if (!squash_guid(szProduct, squished_pc) ||
2482         !squash_guid(szComponent, squished_comp))
2483         return INSTALLSTATE_INVALIDARG;
2484
2485     state = INSTALLSTATE_UNKNOWN;
2486
2487     if (MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkey, FALSE) == ERROR_SUCCESS ||
2488         MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkey, FALSE) == ERROR_SUCCESS)
2489     {
2490         path = msi_reg_get_val_str(hkey, squished_pc);
2491         RegCloseKey(hkey);
2492
2493         state = INSTALLSTATE_ABSENT;
2494
2495         if ((MSIREG_OpenInstallProps(szProduct, MSIINSTALLCONTEXT_MACHINE, NULL,
2496                                      &hkey, FALSE) == ERROR_SUCCESS ||
2497             MSIREG_OpenUserDataProductKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
2498                                           NULL, &hkey, FALSE) == ERROR_SUCCESS) &&
2499             msi_reg_get_val_dword(hkey, wininstaller, &version) &&
2500             GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
2501         {
2502             RegCloseKey(hkey);
2503             state = INSTALLSTATE_LOCAL;
2504         }
2505     }
2506
2507     if (state != INSTALLSTATE_LOCAL &&
2508         (MSIREG_OpenProductKey(szProduct, NULL,
2509                                MSIINSTALLCONTEXT_USERUNMANAGED,
2510                                &hkey, FALSE) == ERROR_SUCCESS ||
2511          MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
2512                                &hkey, FALSE) == ERROR_SUCCESS))
2513     {
2514         RegCloseKey(hkey);
2515
2516         if (MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkey, FALSE) == ERROR_SUCCESS ||
2517             MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkey, FALSE) == ERROR_SUCCESS)
2518         {
2519             msi_free(path);
2520             path = msi_reg_get_val_str(hkey, squished_pc);
2521             RegCloseKey(hkey);
2522
2523             state = INSTALLSTATE_ABSENT;
2524
2525             if (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
2526                 state = INSTALLSTATE_LOCAL;
2527         }
2528     }
2529
2530     if (!path)
2531         return INSTALLSTATE_UNKNOWN;
2532
2533     if (state == INSTALLSTATE_LOCAL && !*path)
2534         state = INSTALLSTATE_NOTUSED;
2535
2536     msi_strcpy_to_awstring(path, lpPathBuf, pcchBuf);
2537     msi_free(path);
2538     return state;
2539 }
2540
2541 /******************************************************************
2542  * MsiGetComponentPathW      [MSI.@]
2543  */
2544 INSTALLSTATE WINAPI MsiGetComponentPathW(LPCWSTR szProduct, LPCWSTR szComponent,
2545                                          LPWSTR lpPathBuf, LPDWORD pcchBuf)
2546 {
2547     awstring path;
2548
2549     path.unicode = TRUE;
2550     path.str.w = lpPathBuf;
2551
2552     return MSI_GetComponentPath( szProduct, szComponent, &path, pcchBuf );
2553 }
2554
2555 /******************************************************************
2556  * MsiGetComponentPathA      [MSI.@]
2557  */
2558 INSTALLSTATE WINAPI MsiGetComponentPathA(LPCSTR szProduct, LPCSTR szComponent,
2559                                          LPSTR lpPathBuf, LPDWORD pcchBuf)
2560 {
2561     LPWSTR szwProduct, szwComponent = NULL;
2562     INSTALLSTATE r = INSTALLSTATE_UNKNOWN;
2563     awstring path;
2564
2565     szwProduct = strdupAtoW( szProduct );
2566     if( szProduct && !szwProduct)
2567         goto end;
2568
2569     szwComponent = strdupAtoW( szComponent );
2570     if( szComponent && !szwComponent )
2571         goto end;
2572
2573     path.unicode = FALSE;
2574     path.str.a = lpPathBuf;
2575
2576     r = MSI_GetComponentPath( szwProduct, szwComponent, &path, pcchBuf );
2577
2578 end:
2579     msi_free( szwProduct );
2580     msi_free( szwComponent );
2581
2582     return r;
2583 }
2584
2585 /******************************************************************
2586  * MsiQueryFeatureStateA      [MSI.@]
2587  */
2588 INSTALLSTATE WINAPI MsiQueryFeatureStateA(LPCSTR szProduct, LPCSTR szFeature)
2589 {
2590     LPWSTR szwProduct = NULL, szwFeature= NULL;
2591     INSTALLSTATE rc = INSTALLSTATE_UNKNOWN;
2592
2593     szwProduct = strdupAtoW( szProduct );
2594     if ( szProduct && !szwProduct )
2595         goto end;
2596
2597     szwFeature = strdupAtoW( szFeature );
2598     if ( szFeature && !szwFeature )
2599         goto end;
2600
2601     rc = MsiQueryFeatureStateW(szwProduct, szwFeature);
2602
2603 end:
2604     msi_free( szwProduct);
2605     msi_free( szwFeature);
2606
2607     return rc;
2608 }
2609
2610 /******************************************************************
2611  * MsiQueryFeatureStateW      [MSI.@]
2612  *
2613  * Checks the state of a feature
2614  *
2615  * PARAMS
2616  *   szProduct     [I]  Product's GUID string
2617  *   szFeature     [I]  Feature's GUID string
2618  *
2619  * RETURNS
2620  *   INSTALLSTATE_LOCAL        Feature is installed and usable
2621  *   INSTALLSTATE_ABSENT       Feature is absent
2622  *   INSTALLSTATE_ADVERTISED   Feature should be installed on demand
2623  *   INSTALLSTATE_UNKNOWN      An error occurred
2624  *   INSTALLSTATE_INVALIDARG   One of the GUIDs was invalid
2625  *
2626  */
2627 INSTALLSTATE WINAPI MsiQueryFeatureStateW(LPCWSTR szProduct, LPCWSTR szFeature)
2628 {
2629     WCHAR squishProduct[33], comp[GUID_SIZE];
2630     GUID guid;
2631     LPWSTR components, p, parent_feature, path;
2632     UINT rc;
2633     HKEY hkey;
2634     INSTALLSTATE r;
2635     BOOL missing = FALSE;
2636     BOOL machine = FALSE;
2637     BOOL source = FALSE;
2638
2639     TRACE("%s %s\n", debugstr_w(szProduct), debugstr_w(szFeature));
2640
2641     if (!szProduct || !szFeature)
2642         return INSTALLSTATE_INVALIDARG;
2643
2644     if (!squash_guid( szProduct, squishProduct ))
2645         return INSTALLSTATE_INVALIDARG;
2646
2647     SetLastError( ERROR_SUCCESS );
2648
2649     if (MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_USERMANAGED,
2650                                &hkey, FALSE) != ERROR_SUCCESS &&
2651         MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
2652                                &hkey, FALSE) != ERROR_SUCCESS)
2653     {
2654         rc = MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_MACHINE,
2655                                     &hkey, FALSE);
2656         if (rc != ERROR_SUCCESS)
2657             return INSTALLSTATE_UNKNOWN;
2658
2659         machine = TRUE;
2660     }
2661
2662     parent_feature = msi_reg_get_val_str( hkey, szFeature );
2663     RegCloseKey(hkey);
2664
2665     if (!parent_feature)
2666         return INSTALLSTATE_UNKNOWN;
2667
2668     r = (parent_feature[0] == 6) ? INSTALLSTATE_ABSENT : INSTALLSTATE_LOCAL;
2669     msi_free(parent_feature);
2670     if (r == INSTALLSTATE_ABSENT)
2671         return r;
2672
2673     if (machine)
2674         rc = MSIREG_OpenUserDataFeaturesKey(szProduct,
2675                                             MSIINSTALLCONTEXT_MACHINE,
2676                                             &hkey, FALSE);
2677     else
2678         rc = MSIREG_OpenUserDataFeaturesKey(szProduct,
2679                                             MSIINSTALLCONTEXT_USERUNMANAGED,
2680                                             &hkey, FALSE);
2681
2682     if (rc != ERROR_SUCCESS)
2683         return INSTALLSTATE_ADVERTISED;
2684
2685     components = msi_reg_get_val_str( hkey, szFeature );
2686     RegCloseKey(hkey);
2687
2688     TRACE("rc = %d buffer = %s\n", rc, debugstr_w(components));
2689
2690     if (!components)
2691         return INSTALLSTATE_ADVERTISED;
2692
2693     for( p = components; *p && *p != 2 ; p += 20)
2694     {
2695         if (!decode_base85_guid( p, &guid ))
2696         {
2697             if (p != components)
2698                 break;
2699
2700             msi_free(components);
2701             return INSTALLSTATE_BADCONFIG;
2702         }
2703
2704         StringFromGUID2(&guid, comp, GUID_SIZE);
2705
2706         if (machine)
2707             rc = MSIREG_OpenUserDataComponentKey(comp, szLocalSid, &hkey, FALSE);
2708         else
2709             rc = MSIREG_OpenUserDataComponentKey(comp, NULL, &hkey, FALSE);
2710
2711         if (rc != ERROR_SUCCESS)
2712         {
2713             msi_free(components);
2714             return INSTALLSTATE_ADVERTISED;
2715         }
2716
2717         path = msi_reg_get_val_str(hkey, squishProduct);
2718         if (!path)
2719             missing = TRUE;
2720         else if (lstrlenW(path) > 2 &&
2721                  path[0] >= '0' && path[0] <= '9' &&
2722                  path[1] >= '0' && path[1] <= '9')
2723         {
2724             source = TRUE;
2725         }
2726
2727         msi_free(path);
2728     }
2729     msi_free(components);
2730
2731     if (missing)
2732         r = INSTALLSTATE_ADVERTISED;
2733     else if (source)
2734         r = INSTALLSTATE_SOURCE;
2735     else
2736         r = INSTALLSTATE_LOCAL;
2737
2738     TRACE("-> %d\n", r);
2739     return r;
2740 }
2741
2742 /******************************************************************
2743  * MsiGetFileVersionA         [MSI.@]
2744  */
2745 UINT WINAPI MsiGetFileVersionA(LPCSTR szFilePath, LPSTR lpVersionBuf,
2746                 LPDWORD pcchVersionBuf, LPSTR lpLangBuf, LPDWORD pcchLangBuf)
2747 {
2748     LPWSTR szwFilePath = NULL, lpwVersionBuff = NULL, lpwLangBuff = NULL;
2749     UINT ret = ERROR_OUTOFMEMORY;
2750
2751     if ((lpVersionBuf && !pcchVersionBuf) ||
2752         (lpLangBuf && !pcchLangBuf))
2753         return ERROR_INVALID_PARAMETER;
2754
2755     if( szFilePath )
2756     {
2757         szwFilePath = strdupAtoW( szFilePath );
2758         if( !szwFilePath )
2759             goto end;
2760     }
2761
2762     if( lpVersionBuf && pcchVersionBuf && *pcchVersionBuf )
2763     {
2764         lpwVersionBuff = msi_alloc(*pcchVersionBuf*sizeof(WCHAR));
2765         if( !lpwVersionBuff )
2766             goto end;
2767     }
2768
2769     if( lpLangBuf && pcchLangBuf && *pcchLangBuf )
2770     {
2771         lpwLangBuff = msi_alloc(*pcchLangBuf*sizeof(WCHAR));
2772         if( !lpwLangBuff )
2773             goto end;
2774     }
2775
2776     ret = MsiGetFileVersionW(szwFilePath, lpwVersionBuff, pcchVersionBuf,
2777                              lpwLangBuff, pcchLangBuf);
2778
2779     if( (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && lpwVersionBuff )
2780         WideCharToMultiByte(CP_ACP, 0, lpwVersionBuff, -1,
2781                             lpVersionBuf, *pcchVersionBuf + 1, NULL, NULL);
2782     if( (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && lpwLangBuff )
2783         WideCharToMultiByte(CP_ACP, 0, lpwLangBuff, -1,
2784                             lpLangBuf, *pcchLangBuf + 1, NULL, NULL);
2785
2786 end:
2787     msi_free(szwFilePath);
2788     msi_free(lpwVersionBuff);
2789     msi_free(lpwLangBuff);
2790
2791     return ret;
2792 }
2793
2794 /******************************************************************
2795  * MsiGetFileVersionW         [MSI.@]
2796  */
2797 UINT WINAPI MsiGetFileVersionW(LPCWSTR szFilePath, LPWSTR lpVersionBuf,
2798                 LPDWORD pcchVersionBuf, LPWSTR lpLangBuf, LPDWORD pcchLangBuf)
2799 {
2800     static const WCHAR szVersionResource[] = {'\\',0};
2801     static const WCHAR szVersionFormat[] = {
2802         '%','d','.','%','d','.','%','d','.','%','d',0};
2803     static const WCHAR szLangResource[] = {
2804         '\\','V','a','r','F','i','l','e','I','n','f','o','\\',
2805         'T','r','a','n','s','l','a','t','i','o','n',0};
2806     static const WCHAR szLangFormat[] = {'%','d',0};
2807     UINT ret = 0;
2808     DWORD dwVerLen, gle;
2809     LPVOID lpVer = NULL;
2810     VS_FIXEDFILEINFO *ffi;
2811     USHORT *lang;
2812     UINT puLen;
2813     WCHAR tmp[32];
2814
2815     TRACE("%s %p %d %p %d\n", debugstr_w(szFilePath),
2816           lpVersionBuf, pcchVersionBuf?*pcchVersionBuf:0,
2817           lpLangBuf, pcchLangBuf?*pcchLangBuf:0);
2818
2819     if ((lpVersionBuf && !pcchVersionBuf) ||
2820         (lpLangBuf && !pcchLangBuf))
2821         return ERROR_INVALID_PARAMETER;
2822
2823     dwVerLen = GetFileVersionInfoSizeW(szFilePath, NULL);
2824     if( !dwVerLen )
2825     {
2826         gle = GetLastError();
2827         if (gle == ERROR_BAD_PATHNAME)
2828             return ERROR_FILE_NOT_FOUND;
2829         else if (gle == ERROR_RESOURCE_DATA_NOT_FOUND)
2830             return ERROR_FILE_INVALID;
2831
2832         return gle;
2833     }
2834
2835     lpVer = msi_alloc(dwVerLen);
2836     if( !lpVer )
2837     {
2838         ret = ERROR_OUTOFMEMORY;
2839         goto end;
2840     }
2841
2842     if( !GetFileVersionInfoW(szFilePath, 0, dwVerLen, lpVer) )
2843     {
2844         ret = GetLastError();
2845         goto end;
2846     }
2847
2848     if (pcchVersionBuf)
2849     {
2850         if( VerQueryValueW(lpVer, szVersionResource, (LPVOID*)&ffi, &puLen) &&
2851             (puLen > 0) )
2852         {
2853             wsprintfW(tmp, szVersionFormat,
2854                   HIWORD(ffi->dwFileVersionMS), LOWORD(ffi->dwFileVersionMS),
2855                   HIWORD(ffi->dwFileVersionLS), LOWORD(ffi->dwFileVersionLS));
2856             if (lpVersionBuf) lstrcpynW(lpVersionBuf, tmp, *pcchVersionBuf);
2857
2858             if (strlenW(tmp) >= *pcchVersionBuf)
2859                 ret = ERROR_MORE_DATA;
2860
2861             *pcchVersionBuf = lstrlenW(tmp);
2862         }
2863         else
2864         {
2865             if (lpVersionBuf) *lpVersionBuf = 0;
2866             *pcchVersionBuf = 0;
2867         }
2868     }
2869
2870     if (pcchLangBuf)
2871     {
2872         if (VerQueryValueW(lpVer, szLangResource, (LPVOID*)&lang, &puLen) &&
2873             (puLen > 0))
2874         {
2875             wsprintfW(tmp, szLangFormat, *lang);
2876             if (lpLangBuf) lstrcpynW(lpLangBuf, tmp, *pcchLangBuf);
2877
2878             if (strlenW(tmp) >= *pcchLangBuf)
2879                 ret = ERROR_MORE_DATA;
2880
2881             *pcchLangBuf = lstrlenW(tmp);
2882         }
2883         else
2884         {
2885             if (lpLangBuf) *lpLangBuf = 0;
2886             *pcchLangBuf = 0;
2887         }
2888     }
2889
2890 end:
2891     msi_free(lpVer);
2892     return ret;
2893 }
2894
2895 /***********************************************************************
2896  * MsiGetFeatureUsageW           [MSI.@]
2897  */
2898 UINT WINAPI MsiGetFeatureUsageW( LPCWSTR szProduct, LPCWSTR szFeature,
2899                                  LPDWORD pdwUseCount, LPWORD pwDateUsed )
2900 {
2901     FIXME("%s %s %p %p\n",debugstr_w(szProduct), debugstr_w(szFeature),
2902           pdwUseCount, pwDateUsed);
2903     return ERROR_CALL_NOT_IMPLEMENTED;
2904 }
2905
2906 /***********************************************************************
2907  * MsiGetFeatureUsageA           [MSI.@]
2908  */
2909 UINT WINAPI MsiGetFeatureUsageA( LPCSTR szProduct, LPCSTR szFeature,
2910                                  LPDWORD pdwUseCount, LPWORD pwDateUsed )
2911 {
2912     LPWSTR prod = NULL, feat = NULL;
2913     UINT ret = ERROR_OUTOFMEMORY;
2914
2915     TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szFeature),
2916           pdwUseCount, pwDateUsed);
2917
2918     prod = strdupAtoW( szProduct );
2919     if (szProduct && !prod)
2920         goto end;
2921
2922     feat = strdupAtoW( szFeature );
2923     if (szFeature && !feat)
2924         goto end;
2925
2926     ret = MsiGetFeatureUsageW( prod, feat, pdwUseCount, pwDateUsed );
2927
2928 end:
2929     msi_free( prod );
2930     msi_free( feat );
2931
2932     return ret;
2933 }
2934
2935 /***********************************************************************
2936  * MsiUseFeatureExW           [MSI.@]
2937  */
2938 INSTALLSTATE WINAPI MsiUseFeatureExW( LPCWSTR szProduct, LPCWSTR szFeature,
2939                                       DWORD dwInstallMode, DWORD dwReserved )
2940 {
2941     INSTALLSTATE state;
2942
2943     TRACE("%s %s %i %i\n", debugstr_w(szProduct), debugstr_w(szFeature),
2944           dwInstallMode, dwReserved);
2945
2946     state = MsiQueryFeatureStateW( szProduct, szFeature );
2947
2948     if (dwReserved)
2949         return INSTALLSTATE_INVALIDARG;
2950
2951     if (state == INSTALLSTATE_LOCAL && dwInstallMode != INSTALLMODE_NODETECTION)
2952     {
2953         FIXME("mark product %s feature %s as used\n",
2954               debugstr_w(szProduct), debugstr_w(szFeature) );
2955     }
2956
2957     return state;
2958 }
2959
2960 /***********************************************************************
2961  * MsiUseFeatureExA           [MSI.@]
2962  */
2963 INSTALLSTATE WINAPI MsiUseFeatureExA( LPCSTR szProduct, LPCSTR szFeature,
2964                                       DWORD dwInstallMode, DWORD dwReserved )
2965 {
2966     INSTALLSTATE ret = INSTALLSTATE_UNKNOWN;
2967     LPWSTR prod = NULL, feat = NULL;
2968
2969     TRACE("%s %s %i %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
2970           dwInstallMode, dwReserved);
2971
2972     prod = strdupAtoW( szProduct );
2973     if (szProduct && !prod)
2974         goto end;
2975
2976     feat = strdupAtoW( szFeature );
2977     if (szFeature && !feat)
2978         goto end;
2979
2980     ret = MsiUseFeatureExW( prod, feat, dwInstallMode, dwReserved );
2981
2982 end:
2983     msi_free( prod );
2984     msi_free( feat );
2985
2986     return ret;
2987 }
2988
2989 /***********************************************************************
2990  * MsiUseFeatureW             [MSI.@]
2991  */
2992 INSTALLSTATE WINAPI MsiUseFeatureW( LPCWSTR szProduct, LPCWSTR szFeature )
2993 {
2994     return MsiUseFeatureExW(szProduct, szFeature, 0, 0);
2995 }
2996
2997 /***********************************************************************
2998  * MsiUseFeatureA             [MSI.@]
2999  */
3000 INSTALLSTATE WINAPI MsiUseFeatureA( LPCSTR szProduct, LPCSTR szFeature )
3001 {
3002     return MsiUseFeatureExA(szProduct, szFeature, 0, 0);
3003 }
3004
3005 /***********************************************************************
3006  * MSI_ProvideQualifiedComponentEx [internal]
3007  */
3008 static UINT MSI_ProvideQualifiedComponentEx(LPCWSTR szComponent,
3009                 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
3010                 DWORD Unused1, DWORD Unused2, awstring *lpPathBuf,
3011                 LPDWORD pcchPathBuf)
3012 {
3013     WCHAR product[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1],
3014           feature[MAX_FEATURE_CHARS+1];
3015     LPWSTR info;
3016     HKEY hkey;
3017     DWORD sz;
3018     UINT rc;
3019
3020     TRACE("%s %s %i %s %i %i %p %p\n", debugstr_w(szComponent),
3021           debugstr_w(szQualifier), dwInstallMode, debugstr_w(szProduct),
3022           Unused1, Unused2, lpPathBuf, pcchPathBuf);
3023
3024     rc = MSIREG_OpenUserComponentsKey(szComponent, &hkey, FALSE);
3025     if (rc != ERROR_SUCCESS)
3026         return ERROR_INDEX_ABSENT;
3027
3028     info = msi_reg_get_val_str( hkey, szQualifier );
3029     RegCloseKey(hkey);
3030
3031     if (!info)
3032         return ERROR_INDEX_ABSENT;
3033
3034     MsiDecomposeDescriptorW(info, product, feature, component, &sz);
3035
3036     if (!szProduct)
3037         rc = MSI_GetComponentPath(product, component, lpPathBuf, pcchPathBuf);
3038     else
3039         rc = MSI_GetComponentPath(szProduct, component, lpPathBuf, pcchPathBuf);
3040
3041     msi_free( info );
3042
3043     if (rc != INSTALLSTATE_LOCAL)
3044         return ERROR_FILE_NOT_FOUND;
3045
3046     return ERROR_SUCCESS;
3047 }
3048
3049 /***********************************************************************
3050  * MsiProvideQualifiedComponentExW [MSI.@]
3051  */
3052 UINT WINAPI MsiProvideQualifiedComponentExW(LPCWSTR szComponent,
3053                 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
3054                 DWORD Unused1, DWORD Unused2, LPWSTR lpPathBuf,
3055                 LPDWORD pcchPathBuf)
3056 {
3057     awstring path;
3058
3059     path.unicode = TRUE;
3060     path.str.w = lpPathBuf;
3061
3062     return MSI_ProvideQualifiedComponentEx(szComponent, szQualifier,
3063             dwInstallMode, szProduct, Unused1, Unused2, &path, pcchPathBuf);
3064 }
3065
3066 /***********************************************************************
3067  * MsiProvideQualifiedComponentExA [MSI.@]
3068  */
3069 UINT WINAPI MsiProvideQualifiedComponentExA(LPCSTR szComponent,
3070                 LPCSTR szQualifier, DWORD dwInstallMode, LPCSTR szProduct,
3071                 DWORD Unused1, DWORD Unused2, LPSTR lpPathBuf,
3072                 LPDWORD pcchPathBuf)
3073 {
3074     LPWSTR szwComponent, szwQualifier = NULL, szwProduct = NULL;
3075     UINT r = ERROR_OUTOFMEMORY;
3076     awstring path;
3077
3078     TRACE("%s %s %u %s %u %u %p %p\n", debugstr_a(szComponent),
3079           debugstr_a(szQualifier), dwInstallMode, debugstr_a(szProduct),
3080           Unused1, Unused2, lpPathBuf, pcchPathBuf);
3081
3082     szwComponent = strdupAtoW( szComponent );
3083     if (szComponent && !szwComponent)
3084         goto end;
3085
3086     szwQualifier = strdupAtoW( szQualifier );
3087     if (szQualifier && !szwQualifier)
3088         goto end;
3089
3090     szwProduct = strdupAtoW( szProduct );
3091     if (szProduct && !szwProduct)
3092         goto end;
3093
3094     path.unicode = FALSE;
3095     path.str.a = lpPathBuf;
3096
3097     r = MSI_ProvideQualifiedComponentEx(szwComponent, szwQualifier,
3098                               dwInstallMode, szwProduct, Unused1,
3099                               Unused2, &path, pcchPathBuf);
3100 end:
3101     msi_free(szwProduct);
3102     msi_free(szwComponent);
3103     msi_free(szwQualifier);
3104
3105     return r;
3106 }
3107
3108 /***********************************************************************
3109  * MsiProvideQualifiedComponentW [MSI.@]
3110  */
3111 UINT WINAPI MsiProvideQualifiedComponentW( LPCWSTR szComponent,
3112                 LPCWSTR szQualifier, DWORD dwInstallMode, LPWSTR lpPathBuf,
3113                 LPDWORD pcchPathBuf)
3114 {
3115     return MsiProvideQualifiedComponentExW(szComponent, szQualifier,
3116                     dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
3117 }
3118
3119 /***********************************************************************
3120  * MsiProvideQualifiedComponentA [MSI.@]
3121  */
3122 UINT WINAPI MsiProvideQualifiedComponentA( LPCSTR szComponent,
3123                 LPCSTR szQualifier, DWORD dwInstallMode, LPSTR lpPathBuf,
3124                 LPDWORD pcchPathBuf)
3125 {
3126     return MsiProvideQualifiedComponentExA(szComponent, szQualifier,
3127                               dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
3128 }
3129
3130 /***********************************************************************
3131  * MSI_GetUserInfo [internal]
3132  */
3133 static USERINFOSTATE MSI_GetUserInfo(LPCWSTR szProduct,
3134                 awstring *lpUserNameBuf, LPDWORD pcchUserNameBuf,
3135                 awstring *lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
3136                 awstring *lpSerialBuf, LPDWORD pcchSerialBuf)
3137 {
3138     WCHAR squished_pc[SQUISH_GUID_SIZE];
3139     LPWSTR user, org, serial;
3140     USERINFOSTATE state;
3141     HKEY hkey, props;
3142     LPCWSTR orgptr;
3143     UINT r;
3144
3145     TRACE("%s %p %p %p %p %p %p\n", debugstr_w(szProduct), lpUserNameBuf,
3146           pcchUserNameBuf, lpOrgNameBuf, pcchOrgNameBuf, lpSerialBuf,
3147           pcchSerialBuf);
3148
3149     if (!szProduct || !squash_guid(szProduct, squished_pc))
3150         return USERINFOSTATE_INVALIDARG;
3151
3152     if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
3153                               &hkey, FALSE) != ERROR_SUCCESS &&
3154         MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3155                               &hkey, FALSE) != ERROR_SUCCESS &&
3156         MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
3157                               &hkey, FALSE) != ERROR_SUCCESS)
3158     {
3159         return USERINFOSTATE_UNKNOWN;
3160     }
3161
3162     if (MSIREG_OpenInstallProps(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
3163                                 NULL, &props, FALSE) != ERROR_SUCCESS &&
3164         MSIREG_OpenInstallProps(szProduct, MSIINSTALLCONTEXT_MACHINE,
3165                                 NULL, &props, FALSE) != ERROR_SUCCESS)
3166     {
3167         RegCloseKey(hkey);
3168         return USERINFOSTATE_ABSENT;
3169     }
3170
3171     user = msi_reg_get_val_str(props, INSTALLPROPERTY_REGOWNERW);
3172     org = msi_reg_get_val_str(props, INSTALLPROPERTY_REGCOMPANYW);
3173     serial = msi_reg_get_val_str(props, INSTALLPROPERTY_PRODUCTIDW);
3174     state = USERINFOSTATE_ABSENT;
3175
3176     RegCloseKey(hkey);
3177     RegCloseKey(props);
3178
3179     if (user && serial)
3180         state = USERINFOSTATE_PRESENT;
3181
3182     if (pcchUserNameBuf)
3183     {
3184         if (lpUserNameBuf && !user)
3185         {
3186             (*pcchUserNameBuf)--;
3187             goto done;
3188         }
3189
3190         r = msi_strcpy_to_awstring(user, lpUserNameBuf, pcchUserNameBuf);
3191         if (r == ERROR_MORE_DATA)
3192         {
3193             state = USERINFOSTATE_MOREDATA;
3194             goto done;
3195         }
3196     }
3197
3198     if (pcchOrgNameBuf)
3199     {
3200         orgptr = org;
3201         if (!orgptr) orgptr = szEmpty;
3202
3203         r = msi_strcpy_to_awstring(orgptr, lpOrgNameBuf, pcchOrgNameBuf);
3204         if (r == ERROR_MORE_DATA)
3205         {
3206             state = USERINFOSTATE_MOREDATA;
3207             goto done;
3208         }
3209     }
3210
3211     if (pcchSerialBuf)
3212     {
3213         if (!serial)
3214         {
3215             (*pcchSerialBuf)--;
3216             goto done;
3217         }
3218
3219         r = msi_strcpy_to_awstring(serial, lpSerialBuf, pcchSerialBuf);
3220         if (r == ERROR_MORE_DATA)
3221             state = USERINFOSTATE_MOREDATA;
3222     }
3223
3224 done:
3225     msi_free(user);
3226     msi_free(org);
3227     msi_free(serial);
3228
3229     return state;
3230 }
3231
3232 /***********************************************************************
3233  * MsiGetUserInfoW [MSI.@]
3234  */
3235 USERINFOSTATE WINAPI MsiGetUserInfoW(LPCWSTR szProduct,
3236                 LPWSTR lpUserNameBuf, LPDWORD pcchUserNameBuf,
3237                 LPWSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
3238                 LPWSTR lpSerialBuf, LPDWORD pcchSerialBuf)
3239 {
3240     awstring user, org, serial;
3241
3242     if ((lpUserNameBuf && !pcchUserNameBuf) ||
3243         (lpOrgNameBuf && !pcchOrgNameBuf) ||
3244         (lpSerialBuf && !pcchSerialBuf))
3245         return USERINFOSTATE_INVALIDARG;
3246
3247     user.unicode = TRUE;
3248     user.str.w = lpUserNameBuf;
3249     org.unicode = TRUE;
3250     org.str.w = lpOrgNameBuf;
3251     serial.unicode = TRUE;
3252     serial.str.w = lpSerialBuf;
3253
3254     return MSI_GetUserInfo( szProduct, &user, pcchUserNameBuf,
3255                             &org, pcchOrgNameBuf,
3256                             &serial, pcchSerialBuf );
3257 }
3258
3259 USERINFOSTATE WINAPI MsiGetUserInfoA(LPCSTR szProduct,
3260                 LPSTR lpUserNameBuf, LPDWORD pcchUserNameBuf,
3261                 LPSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
3262                 LPSTR lpSerialBuf, LPDWORD pcchSerialBuf)
3263 {
3264     awstring user, org, serial;
3265     LPWSTR prod;
3266     UINT r;
3267
3268     if ((lpUserNameBuf && !pcchUserNameBuf) ||
3269         (lpOrgNameBuf && !pcchOrgNameBuf) ||
3270         (lpSerialBuf && !pcchSerialBuf))
3271         return USERINFOSTATE_INVALIDARG;
3272
3273     prod = strdupAtoW( szProduct );
3274     if (szProduct && !prod)
3275         return ERROR_OUTOFMEMORY;
3276
3277     user.unicode = FALSE;
3278     user.str.a = lpUserNameBuf;
3279     org.unicode = FALSE;
3280     org.str.a = lpOrgNameBuf;
3281     serial.unicode = FALSE;
3282     serial.str.a = lpSerialBuf;
3283
3284     r = MSI_GetUserInfo( prod, &user, pcchUserNameBuf,
3285                          &org, pcchOrgNameBuf,
3286                          &serial, pcchSerialBuf );
3287
3288     msi_free( prod );
3289
3290     return r;
3291 }
3292
3293 UINT WINAPI MsiCollectUserInfoW(LPCWSTR szProduct)
3294 {
3295     MSIHANDLE handle;
3296     UINT rc;
3297     MSIPACKAGE *package;
3298     static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
3299
3300     TRACE("(%s)\n",debugstr_w(szProduct));
3301
3302     rc = MsiOpenProductW(szProduct,&handle);
3303     if (rc != ERROR_SUCCESS)
3304         return ERROR_INVALID_PARAMETER;
3305
3306     /* MsiCollectUserInfo cannot be called from a custom action. */
3307     package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
3308     if (!package)
3309         return ERROR_CALL_NOT_IMPLEMENTED;
3310
3311     rc = ACTION_PerformUIAction(package, szFirstRun, -1);
3312     msiobj_release( &package->hdr );
3313
3314     MsiCloseHandle(handle);
3315
3316     return rc;
3317 }
3318
3319 UINT WINAPI MsiCollectUserInfoA(LPCSTR szProduct)
3320 {
3321     MSIHANDLE handle;
3322     UINT rc;
3323     MSIPACKAGE *package;
3324     static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
3325
3326     TRACE("(%s)\n",debugstr_a(szProduct));
3327
3328     rc = MsiOpenProductA(szProduct,&handle);
3329     if (rc != ERROR_SUCCESS)
3330         return ERROR_INVALID_PARAMETER;
3331
3332     /* MsiCollectUserInfo cannot be called from a custom action. */
3333     package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
3334     if (!package)
3335         return ERROR_CALL_NOT_IMPLEMENTED;
3336
3337     rc = ACTION_PerformUIAction(package, szFirstRun, -1);
3338     msiobj_release( &package->hdr );
3339
3340     MsiCloseHandle(handle);
3341
3342     return rc;
3343 }
3344
3345 /***********************************************************************
3346  * MsiConfigureFeatureA            [MSI.@]
3347  */
3348 UINT WINAPI MsiConfigureFeatureA(LPCSTR szProduct, LPCSTR szFeature, INSTALLSTATE eInstallState)
3349 {
3350     LPWSTR prod, feat = NULL;
3351     UINT r = ERROR_OUTOFMEMORY;
3352
3353     TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature), eInstallState);
3354
3355     prod = strdupAtoW( szProduct );
3356     if (szProduct && !prod)
3357         goto end;
3358
3359     feat = strdupAtoW( szFeature );
3360     if (szFeature && !feat)
3361         goto end;
3362
3363     r = MsiConfigureFeatureW(prod, feat, eInstallState);
3364
3365 end:
3366     msi_free(feat);
3367     msi_free(prod);
3368
3369     return r;
3370 }
3371
3372 /***********************************************************************
3373  * MsiConfigureFeatureW            [MSI.@]
3374  */
3375 UINT WINAPI MsiConfigureFeatureW(LPCWSTR szProduct, LPCWSTR szFeature, INSTALLSTATE eInstallState)
3376 {
3377     static const WCHAR szCostInit[] = { 'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0 };
3378     MSIPACKAGE *package = NULL;
3379     UINT r;
3380     WCHAR sourcepath[MAX_PATH], filename[MAX_PATH];
3381     DWORD sz;
3382
3383     TRACE("%s %s %i\n", debugstr_w(szProduct), debugstr_w(szFeature), eInstallState);
3384
3385     if (!szProduct || !szFeature)
3386         return ERROR_INVALID_PARAMETER;
3387
3388     switch (eInstallState)
3389     {
3390     case INSTALLSTATE_DEFAULT:
3391         /* FIXME: how do we figure out the default location? */
3392         eInstallState = INSTALLSTATE_LOCAL;
3393         break;
3394     case INSTALLSTATE_LOCAL:
3395     case INSTALLSTATE_SOURCE:
3396     case INSTALLSTATE_ABSENT:
3397     case INSTALLSTATE_ADVERTISED:
3398         break;
3399     default:
3400         return ERROR_INVALID_PARAMETER;
3401     }
3402
3403     r = MSI_OpenProductW( szProduct, &package );
3404     if (r != ERROR_SUCCESS)
3405         return r;
3406
3407     sz = sizeof(sourcepath);
3408     MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3409                 MSICODE_PRODUCT, INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
3410
3411     sz = sizeof(filename);
3412     MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3413                 MSICODE_PRODUCT, INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
3414
3415     lstrcatW( sourcepath, filename );
3416
3417     MsiSetInternalUI( INSTALLUILEVEL_BASIC, NULL );
3418
3419     r = ACTION_PerformUIAction( package, szCostInit, -1 );
3420     if (r != ERROR_SUCCESS)
3421         goto end;
3422
3423     r = MSI_SetFeatureStateW( package, szFeature, eInstallState);
3424     if (r != ERROR_SUCCESS)
3425         goto end;
3426
3427     r = MSI_InstallPackage( package, sourcepath, NULL );
3428
3429 end:
3430     msiobj_release( &package->hdr );
3431
3432     return r;
3433 }
3434
3435 /***********************************************************************
3436  * MsiCreateAndVerifyInstallerDirectory [MSI.@]
3437  *
3438  * Notes: undocumented
3439  */
3440 UINT WINAPI MsiCreateAndVerifyInstallerDirectory(DWORD dwReserved)
3441 {
3442     WCHAR path[MAX_PATH];
3443
3444     TRACE("%d\n", dwReserved);
3445
3446     if (dwReserved)
3447     {
3448         FIXME("dwReserved=%d\n", dwReserved);
3449         return ERROR_INVALID_PARAMETER;
3450     }
3451
3452     if (!GetWindowsDirectoryW(path, MAX_PATH))
3453         return ERROR_FUNCTION_FAILED;
3454
3455     lstrcatW(path, installerW);
3456
3457     if (!CreateDirectoryW(path, NULL))
3458         return ERROR_FUNCTION_FAILED;
3459
3460     return ERROR_SUCCESS;
3461 }
3462
3463 /***********************************************************************
3464  * MsiGetShortcutTargetA           [MSI.@]
3465  */
3466 UINT WINAPI MsiGetShortcutTargetA( LPCSTR szShortcutTarget,
3467                                    LPSTR szProductCode, LPSTR szFeatureId,
3468                                    LPSTR szComponentCode )
3469 {
3470     LPWSTR target;
3471     const int len = MAX_FEATURE_CHARS+1;
3472     WCHAR product[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1];
3473     UINT r;
3474
3475     target = strdupAtoW( szShortcutTarget );
3476     if (szShortcutTarget && !target )
3477         return ERROR_OUTOFMEMORY;
3478     product[0] = 0;
3479     feature[0] = 0;
3480     component[0] = 0;
3481     r = MsiGetShortcutTargetW( target, product, feature, component );
3482     msi_free( target );
3483     if (r == ERROR_SUCCESS)
3484     {
3485         WideCharToMultiByte( CP_ACP, 0, product, -1, szProductCode, len, NULL, NULL );
3486         WideCharToMultiByte( CP_ACP, 0, feature, -1, szFeatureId, len, NULL, NULL );
3487         WideCharToMultiByte( CP_ACP, 0, component, -1, szComponentCode, len, NULL, NULL );
3488     }
3489     return r;
3490 }
3491
3492 /***********************************************************************
3493  * MsiGetShortcutTargetW           [MSI.@]
3494  */
3495 UINT WINAPI MsiGetShortcutTargetW( LPCWSTR szShortcutTarget,
3496                                    LPWSTR szProductCode, LPWSTR szFeatureId,
3497                                    LPWSTR szComponentCode )
3498 {
3499     IShellLinkDataList *dl = NULL;
3500     IPersistFile *pf = NULL;
3501     LPEXP_DARWIN_LINK darwin = NULL;
3502     HRESULT r, init;
3503
3504     TRACE("%s %p %p %p\n", debugstr_w(szShortcutTarget),
3505           szProductCode, szFeatureId, szComponentCode );
3506
3507     init = CoInitialize(NULL);
3508
3509     r = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3510                           &IID_IPersistFile, (LPVOID*) &pf );
3511     if( SUCCEEDED( r ) )
3512     {
3513         r = IPersistFile_Load( pf, szShortcutTarget,
3514                                STGM_READ | STGM_SHARE_DENY_WRITE );
3515         if( SUCCEEDED( r ) )
3516         {
3517             r = IPersistFile_QueryInterface( pf, &IID_IShellLinkDataList,
3518                                              (LPVOID*) &dl );
3519             if( SUCCEEDED( r ) )
3520             {
3521                 IShellLinkDataList_CopyDataBlock( dl, EXP_DARWIN_ID_SIG,
3522                                                   (LPVOID) &darwin );
3523                 IShellLinkDataList_Release( dl );
3524             }
3525         }
3526         IPersistFile_Release( pf );
3527     }
3528
3529     if (SUCCEEDED(init))
3530         CoUninitialize();
3531
3532     TRACE("darwin = %p\n", darwin);
3533
3534     if (darwin)
3535     {
3536         DWORD sz;
3537         UINT ret;
3538
3539         ret = MsiDecomposeDescriptorW( darwin->szwDarwinID,
3540                   szProductCode, szFeatureId, szComponentCode, &sz );
3541         LocalFree( darwin );
3542         return ret;
3543     }
3544
3545     return ERROR_FUNCTION_FAILED;
3546 }
3547
3548 UINT WINAPI MsiReinstallFeatureW( LPCWSTR szProduct, LPCWSTR szFeature,
3549                                   DWORD dwReinstallMode )
3550 {
3551     MSIPACKAGE* package = NULL;
3552     UINT r;
3553     WCHAR sourcepath[MAX_PATH];
3554     WCHAR filename[MAX_PATH];
3555     static const WCHAR szLogVerbose[] = {
3556         ' ','L','O','G','V','E','R','B','O','S','E',0 };
3557     WCHAR reinstallmode[11];
3558     LPWSTR ptr;
3559     DWORD sz;
3560
3561     FIXME("%s %s 0x%08x\n",
3562           debugstr_w(szProduct), debugstr_w(szFeature), dwReinstallMode);
3563
3564     ptr = reinstallmode;
3565
3566     if (dwReinstallMode & REINSTALLMODE_FILEMISSING)
3567         *ptr++ = 'p';
3568     if (dwReinstallMode & REINSTALLMODE_FILEOLDERVERSION)
3569         *ptr++ = 'o';
3570     if (dwReinstallMode & REINSTALLMODE_FILEEQUALVERSION)
3571         *ptr++ = 'w';
3572     if (dwReinstallMode & REINSTALLMODE_FILEEXACT)
3573         *ptr++ = 'd';
3574     if (dwReinstallMode & REINSTALLMODE_FILEVERIFY)
3575         *ptr++ = 'c';
3576     if (dwReinstallMode & REINSTALLMODE_FILEREPLACE)
3577         *ptr++ = 'a';
3578     if (dwReinstallMode & REINSTALLMODE_USERDATA)
3579         *ptr++ = 'u';
3580     if (dwReinstallMode & REINSTALLMODE_MACHINEDATA)
3581         *ptr++ = 'm';
3582     if (dwReinstallMode & REINSTALLMODE_SHORTCUT)
3583         *ptr++ = 's';
3584     if (dwReinstallMode & REINSTALLMODE_PACKAGE)
3585         *ptr++ = 'v';
3586     *ptr = 0;
3587
3588     sz = sizeof(sourcepath);
3589     MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3590             MSICODE_PRODUCT, INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
3591
3592     sz = sizeof(filename);
3593     MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3594             MSICODE_PRODUCT, INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
3595
3596     lstrcatW( sourcepath, filename );
3597
3598     if (dwReinstallMode & REINSTALLMODE_PACKAGE)
3599         r = MSI_OpenPackageW( sourcepath, &package );
3600     else
3601         r = MSI_OpenProductW( szProduct, &package );
3602
3603     if (r != ERROR_SUCCESS)
3604         return r;
3605
3606     msi_set_property( package->db, szReinstallMode, reinstallmode );
3607     msi_set_property( package->db, szInstalled, szOne );
3608     msi_set_property( package->db, szLogVerbose, szOne );
3609     msi_set_property( package->db, szReinstall, szFeature );
3610
3611     r = MSI_InstallPackage( package, sourcepath, NULL );
3612
3613     msiobj_release( &package->hdr );
3614
3615     return r;
3616 }
3617
3618 UINT WINAPI MsiReinstallFeatureA( LPCSTR szProduct, LPCSTR szFeature,
3619                                   DWORD dwReinstallMode )
3620 {
3621     LPWSTR wszProduct;
3622     LPWSTR wszFeature;
3623     UINT rc;
3624
3625     TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
3626                            dwReinstallMode);
3627
3628     wszProduct = strdupAtoW(szProduct);
3629     wszFeature = strdupAtoW(szFeature);
3630
3631     rc = MsiReinstallFeatureW(wszProduct, wszFeature, dwReinstallMode);
3632
3633     msi_free(wszProduct);
3634     msi_free(wszFeature);
3635     return rc;
3636 }
3637
3638 typedef struct
3639 {
3640     unsigned int i[2];
3641     unsigned int buf[4];
3642     unsigned char in[64];
3643     unsigned char digest[16];
3644 } MD5_CTX;
3645
3646 extern VOID WINAPI MD5Init( MD5_CTX *);
3647 extern VOID WINAPI MD5Update( MD5_CTX *, const unsigned char *, unsigned int );
3648 extern VOID WINAPI MD5Final( MD5_CTX *);
3649
3650 /***********************************************************************
3651  * MsiGetFileHashW            [MSI.@]
3652  */
3653 UINT WINAPI MsiGetFileHashW( LPCWSTR szFilePath, DWORD dwOptions,
3654                              PMSIFILEHASHINFO pHash )
3655 {
3656     HANDLE handle, mapping;
3657     void *p;
3658     DWORD length;
3659     UINT r = ERROR_FUNCTION_FAILED;
3660
3661     TRACE("%s %08x %p\n", debugstr_w(szFilePath), dwOptions, pHash );
3662
3663     if (!szFilePath)
3664         return ERROR_INVALID_PARAMETER;
3665
3666     if (!*szFilePath)
3667         return ERROR_PATH_NOT_FOUND;
3668
3669     if (dwOptions)
3670         return ERROR_INVALID_PARAMETER;
3671     if (!pHash)
3672         return ERROR_INVALID_PARAMETER;
3673     if (pHash->dwFileHashInfoSize < sizeof *pHash)
3674         return ERROR_INVALID_PARAMETER;
3675
3676     handle = CreateFileW( szFilePath, GENERIC_READ,
3677                           FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, NULL );
3678     if (handle == INVALID_HANDLE_VALUE)
3679     {
3680         WARN("can't open file %u\n", GetLastError());
3681         return ERROR_FILE_NOT_FOUND;
3682     }
3683     length = GetFileSize( handle, NULL );
3684
3685     mapping = CreateFileMappingW( handle, NULL, PAGE_READONLY, 0, 0, NULL );
3686     if (mapping)
3687     {
3688         p = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, length );
3689         if (p)
3690         {
3691             MD5_CTX ctx;
3692
3693             MD5Init( &ctx );
3694             MD5Update( &ctx, p, length );
3695             MD5Final( &ctx );
3696             UnmapViewOfFile( p );
3697
3698             memcpy( pHash->dwData, ctx.digest, sizeof pHash->dwData );
3699             r = ERROR_SUCCESS;
3700         }
3701         CloseHandle( mapping );
3702     }
3703     CloseHandle( handle );
3704
3705     return r;
3706 }
3707
3708 /***********************************************************************
3709  * MsiGetFileHashA            [MSI.@]
3710  */
3711 UINT WINAPI MsiGetFileHashA( LPCSTR szFilePath, DWORD dwOptions,
3712                              PMSIFILEHASHINFO pHash )
3713 {
3714     LPWSTR file;
3715     UINT r;
3716
3717     TRACE("%s %08x %p\n", debugstr_a(szFilePath), dwOptions, pHash );
3718
3719     file = strdupAtoW( szFilePath );
3720     if (szFilePath && !file)
3721         return ERROR_OUTOFMEMORY;
3722
3723     r = MsiGetFileHashW( file, dwOptions, pHash );
3724     msi_free( file );
3725     return r;
3726 }
3727
3728 /***********************************************************************
3729  * MsiAdvertiseScriptW        [MSI.@]
3730  */
3731 UINT WINAPI MsiAdvertiseScriptW( LPCWSTR szScriptFile, DWORD dwFlags,
3732                                  PHKEY phRegData, BOOL fRemoveItems )
3733 {
3734     FIXME("%s %08x %p %d\n",
3735           debugstr_w( szScriptFile ), dwFlags, phRegData, fRemoveItems );
3736     return ERROR_CALL_NOT_IMPLEMENTED;
3737 }
3738
3739 /***********************************************************************
3740  * MsiAdvertiseScriptA        [MSI.@]
3741  */
3742 UINT WINAPI MsiAdvertiseScriptA( LPCSTR szScriptFile, DWORD dwFlags,
3743                                  PHKEY phRegData, BOOL fRemoveItems )
3744 {
3745     FIXME("%s %08x %p %d\n",
3746           debugstr_a( szScriptFile ), dwFlags, phRegData, fRemoveItems );
3747     return ERROR_CALL_NOT_IMPLEMENTED;
3748 }
3749
3750 /***********************************************************************
3751  * MsiIsProductElevatedW        [MSI.@]
3752  */
3753 UINT WINAPI MsiIsProductElevatedW( LPCWSTR szProduct, BOOL *pfElevated )
3754 {
3755     FIXME("%s %p - stub\n",
3756           debugstr_w( szProduct ), pfElevated );
3757     *pfElevated = TRUE;
3758     return ERROR_SUCCESS;
3759 }
3760
3761 /***********************************************************************
3762  * MsiIsProductElevatedA        [MSI.@]
3763  */
3764 UINT WINAPI MsiIsProductElevatedA( LPCSTR szProduct, BOOL *pfElevated )
3765 {
3766     FIXME("%s %p - stub\n",
3767           debugstr_a( szProduct ), pfElevated );
3768     *pfElevated = TRUE;
3769     return ERROR_SUCCESS;
3770 }
3771
3772 /***********************************************************************
3773  * MsiSetExternalUIRecord     [MSI.@]
3774  */
3775 UINT WINAPI MsiSetExternalUIRecord( INSTALLUI_HANDLER_RECORD handler,
3776                                     DWORD filter, LPVOID context,
3777                                     PINSTALLUI_HANDLER_RECORD prev )
3778 {
3779     TRACE("%p %08x %p %p\n", handler, filter, context, prev);
3780
3781     if (prev)
3782         *prev = gUIHandlerRecord;
3783
3784     gUIHandlerRecord = handler;
3785     gUIFilter        = filter;
3786     gUIContext       = context;
3787
3788     return ERROR_SUCCESS;
3789 }
3790
3791 /***********************************************************************
3792  * MsiInstallMissingComponentA     [MSI.@]
3793  */
3794 UINT WINAPI MsiInstallMissingComponentA( LPCSTR product, LPCSTR component, INSTALLSTATE state )
3795 {
3796     UINT r;
3797     WCHAR *productW = NULL, *componentW = NULL;
3798
3799     TRACE("%s, %s, %d\n", debugstr_a(product), debugstr_a(component), state);
3800
3801     if (product && !(productW = strdupAtoW( product )))
3802         return ERROR_OUTOFMEMORY;
3803
3804     if (component && !(componentW = strdupAtoW( component )))
3805     {
3806         msi_free( productW );
3807         return ERROR_OUTOFMEMORY;
3808     }
3809
3810     r = MsiInstallMissingComponentW( productW, componentW, state );
3811     msi_free( productW );
3812     msi_free( componentW );
3813     return r;
3814 }
3815
3816 /***********************************************************************
3817  * MsiInstallMissingComponentW     [MSI.@]
3818  */
3819 UINT WINAPI MsiInstallMissingComponentW(LPCWSTR szProduct, LPCWSTR szComponent, INSTALLSTATE eInstallState)
3820 {
3821     FIXME("(%s %s %d\n", debugstr_w(szProduct), debugstr_w(szComponent), eInstallState);
3822     return ERROR_SUCCESS;
3823 }
3824
3825 /***********************************************************************
3826  * MsiBeginTransactionA     [MSI.@]
3827  */
3828 UINT WINAPI MsiBeginTransactionA( LPCSTR name, DWORD attrs, MSIHANDLE *id, HANDLE *event )
3829 {
3830     WCHAR *nameW;
3831     UINT r;
3832
3833     FIXME("%s %u %p %p\n", debugstr_a(name), attrs, id, event);
3834
3835     nameW = strdupAtoW( name );
3836     if (name && !nameW)
3837         return ERROR_OUTOFMEMORY;
3838
3839     r = MsiBeginTransactionW( nameW, attrs, id, event );
3840     msi_free( nameW );
3841     return r;
3842 }
3843
3844 /***********************************************************************
3845  * MsiBeginTransactionW     [MSI.@]
3846  */
3847 UINT WINAPI MsiBeginTransactionW( LPCWSTR name, DWORD attrs, MSIHANDLE *id, HANDLE *event )
3848 {
3849     FIXME("%s %u %p %p\n", debugstr_w(name), attrs, id, event);
3850
3851     *id = (MSIHANDLE)0xdeadbeef;
3852     *event = (HANDLE)0xdeadbeef;
3853
3854     return ERROR_SUCCESS;
3855 }
3856
3857 /***********************************************************************
3858  * MsiEndTransaction     [MSI.@]
3859  */
3860 UINT WINAPI MsiEndTransaction( DWORD state )
3861 {
3862     FIXME("%u\n", state);
3863     return ERROR_SUCCESS;
3864 }