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