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