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     static WCHAR empty[] = {0};
1105     static const WCHAR sourcelist[] = {'S','o','u','r','c','e','L','i','s','t',0};
1106     static const WCHAR display_name[] = {'D','i','s','p','l','a','y','N','a','m','e',0};
1107     static const WCHAR display_version[] = {'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0};
1108     static const WCHAR assignment[] = {'A','s','s','i','g','n','m','e','n','t',0};
1109     MSIINSTALLCONTEXT context = MSIINSTALLCONTEXT_USERUNMANAGED;
1110     UINT r = ERROR_UNKNOWN_PROPERTY;
1111     HKEY prodkey, userdata, source;
1112     LPWSTR val = NULL;
1113     WCHAR squished_pc[GUID_SIZE];
1114     WCHAR packagecode[GUID_SIZE];
1115     BOOL badconfig = FALSE;
1116     LONG res;
1117     DWORD type = REG_NONE;
1118
1119     TRACE("%s %s %p %p\n", debugstr_w(szProduct),
1120           debugstr_w(szAttribute), szValue, pcchValueBuf);
1121
1122     if ((szValue->str.w && !pcchValueBuf) || !szProduct || !szAttribute)
1123         return ERROR_INVALID_PARAMETER;
1124
1125     if (!squash_guid(szProduct, squished_pc))
1126         return ERROR_INVALID_PARAMETER;
1127
1128     if ((r = MSIREG_OpenProductKey(szProduct, NULL,
1129                                    MSIINSTALLCONTEXT_USERMANAGED,
1130                                    &prodkey, FALSE)) != ERROR_SUCCESS &&
1131         (r = MSIREG_OpenProductKey(szProduct, NULL,
1132                                    MSIINSTALLCONTEXT_USERUNMANAGED,
1133                                    &prodkey, FALSE)) != ERROR_SUCCESS &&
1134         (r = MSIREG_OpenProductKey(szProduct, NULL,
1135                                    MSIINSTALLCONTEXT_MACHINE,
1136                                     &prodkey, FALSE)) == ERROR_SUCCESS)
1137     {
1138         context = MSIINSTALLCONTEXT_MACHINE;
1139     }
1140
1141     MSIREG_OpenInstallProps(szProduct, context, NULL, &userdata, FALSE);
1142
1143     if (!strcmpW( szAttribute, INSTALLPROPERTY_HELPLINKW ) ||
1144         !strcmpW( szAttribute, INSTALLPROPERTY_HELPTELEPHONEW ) ||
1145         !strcmpW( szAttribute, INSTALLPROPERTY_INSTALLDATEW ) ||
1146         !strcmpW( szAttribute, INSTALLPROPERTY_INSTALLEDPRODUCTNAMEW ) ||
1147         !strcmpW( szAttribute, INSTALLPROPERTY_INSTALLLOCATIONW ) ||
1148         !strcmpW( szAttribute, INSTALLPROPERTY_INSTALLSOURCEW ) ||
1149         !strcmpW( szAttribute, INSTALLPROPERTY_LOCALPACKAGEW ) ||
1150         !strcmpW( szAttribute, INSTALLPROPERTY_PUBLISHERW ) ||
1151         !strcmpW( szAttribute, INSTALLPROPERTY_URLINFOABOUTW ) ||
1152         !strcmpW( szAttribute, INSTALLPROPERTY_URLUPDATEINFOW ) ||
1153         !strcmpW( szAttribute, INSTALLPROPERTY_VERSIONMINORW ) ||
1154         !strcmpW( szAttribute, INSTALLPROPERTY_VERSIONMAJORW ) ||
1155         !strcmpW( szAttribute, INSTALLPROPERTY_VERSIONSTRINGW ) ||
1156         !strcmpW( szAttribute, INSTALLPROPERTY_PRODUCTIDW ) ||
1157         !strcmpW( szAttribute, INSTALLPROPERTY_REGCOMPANYW ) ||
1158         !strcmpW( szAttribute, INSTALLPROPERTY_REGOWNERW ))
1159     {
1160         if (!prodkey)
1161         {
1162             r = ERROR_UNKNOWN_PRODUCT;
1163             goto done;
1164         }
1165
1166         if (!userdata)
1167             return ERROR_UNKNOWN_PROPERTY;
1168
1169         if (!strcmpW( szAttribute, INSTALLPROPERTY_INSTALLEDPRODUCTNAMEW ))
1170             szAttribute = display_name;
1171         else if (!strcmpW( szAttribute, INSTALLPROPERTY_VERSIONSTRINGW ))
1172             szAttribute = display_version;
1173
1174         val = msi_reg_get_value(userdata, szAttribute, &type);
1175         if (!val)
1176             val = empty;
1177     }
1178     else if (!strcmpW( szAttribute, INSTALLPROPERTY_INSTANCETYPEW ) ||
1179              !strcmpW( szAttribute, INSTALLPROPERTY_TRANSFORMSW ) ||
1180              !strcmpW( szAttribute, INSTALLPROPERTY_LANGUAGEW ) ||
1181              !strcmpW( szAttribute, INSTALLPROPERTY_PRODUCTNAMEW ) ||
1182              !strcmpW( szAttribute, INSTALLPROPERTY_ASSIGNMENTTYPEW ) ||
1183              !strcmpW( szAttribute, INSTALLPROPERTY_PACKAGECODEW ) ||
1184              !strcmpW( szAttribute, INSTALLPROPERTY_VERSIONW ) ||
1185              !strcmpW( szAttribute, INSTALLPROPERTY_PRODUCTICONW ) ||
1186              !strcmpW( szAttribute, INSTALLPROPERTY_PACKAGENAMEW ) ||
1187              !strcmpW( szAttribute, INSTALLPROPERTY_AUTHORIZED_LUA_APPW ))
1188     {
1189         if (!prodkey)
1190         {
1191             r = ERROR_UNKNOWN_PRODUCT;
1192             goto done;
1193         }
1194
1195         if (!strcmpW( szAttribute, INSTALLPROPERTY_ASSIGNMENTTYPEW ))
1196             szAttribute = assignment;
1197
1198         if (!strcmpW( szAttribute, INSTALLPROPERTY_PACKAGENAMEW ))
1199         {
1200             res = RegOpenKeyW(prodkey, sourcelist, &source);
1201             if (res != ERROR_SUCCESS)
1202             {
1203                 r = ERROR_UNKNOWN_PRODUCT;
1204                 goto done;
1205             }
1206
1207             val = msi_reg_get_value(source, szAttribute, &type);
1208             if (!val)
1209                 val = empty;
1210
1211             RegCloseKey(source);
1212         }
1213         else
1214         {
1215             val = msi_reg_get_value(prodkey, szAttribute, &type);
1216             if (!val)
1217                 val = empty;
1218         }
1219
1220         if (val != empty && type != REG_DWORD &&
1221             !strcmpW( szAttribute, INSTALLPROPERTY_PACKAGECODEW ))
1222         {
1223             if (lstrlenW(val) != SQUISH_GUID_SIZE - 1)
1224                 badconfig = TRUE;
1225             else
1226             {
1227                 unsquash_guid(val, packagecode);
1228                 msi_free(val);
1229                 val = strdupW(packagecode);
1230             }
1231         }
1232     }
1233
1234     if (!val)
1235     {
1236         r = ERROR_UNKNOWN_PROPERTY;
1237         goto done;
1238     }
1239
1240     if (pcchValueBuf)
1241     {
1242         int len = strlenW( val );
1243
1244         /* If szBuffer (szValue->str) is NULL, there's no need to copy the value
1245          * out.  Also, *pcchValueBuf may be uninitialized in this case, so we
1246          * can't rely on its value.
1247          */
1248         if (szValue->str.a || szValue->str.w)
1249         {
1250             DWORD size = *pcchValueBuf;
1251             if (len < size)
1252                 r = msi_strcpy_to_awstring( val, len, szValue, &size );
1253             else
1254                 r = ERROR_MORE_DATA;
1255         }
1256
1257         if (!badconfig)
1258             *pcchValueBuf = len;
1259     }
1260
1261     if (badconfig)
1262         r = ERROR_BAD_CONFIGURATION;
1263
1264     if (val != empty)
1265         msi_free(val);
1266
1267 done:
1268     RegCloseKey(prodkey);
1269     RegCloseKey(userdata);
1270     return r;
1271 }
1272
1273 UINT WINAPI MsiGetProductInfoA(LPCSTR szProduct, LPCSTR szAttribute,
1274                                LPSTR szBuffer, LPDWORD pcchValueBuf)
1275 {
1276     LPWSTR szwProduct, szwAttribute = NULL;
1277     UINT r = ERROR_OUTOFMEMORY;
1278     awstring buffer;
1279
1280     TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szAttribute),
1281           szBuffer, pcchValueBuf);
1282
1283     szwProduct = strdupAtoW( szProduct );
1284     if( szProduct && !szwProduct )
1285         goto end;
1286
1287     szwAttribute = strdupAtoW( szAttribute );
1288     if( szAttribute && !szwAttribute )
1289         goto end;
1290
1291     buffer.unicode = FALSE;
1292     buffer.str.a = szBuffer;
1293
1294     r = MSI_GetProductInfo( szwProduct, szwAttribute,
1295                             &buffer, pcchValueBuf );
1296
1297 end:
1298     msi_free( szwProduct );
1299     msi_free( szwAttribute );
1300
1301     return r;
1302 }
1303
1304 UINT WINAPI MsiGetProductInfoW(LPCWSTR szProduct, LPCWSTR szAttribute,
1305                                LPWSTR szBuffer, LPDWORD pcchValueBuf)
1306 {
1307     awstring buffer;
1308
1309     TRACE("%s %s %p %p\n", debugstr_w(szProduct), debugstr_w(szAttribute),
1310           szBuffer, pcchValueBuf);
1311
1312     buffer.unicode = TRUE;
1313     buffer.str.w = szBuffer;
1314
1315     return MSI_GetProductInfo( szProduct, szAttribute,
1316                                &buffer, pcchValueBuf );
1317 }
1318
1319 UINT WINAPI MsiGetProductInfoExA(LPCSTR szProductCode, LPCSTR szUserSid,
1320                                  MSIINSTALLCONTEXT dwContext, LPCSTR szProperty,
1321                                  LPSTR szValue, LPDWORD pcchValue)
1322 {
1323     LPWSTR product = NULL;
1324     LPWSTR usersid = NULL;
1325     LPWSTR property = NULL;
1326     LPWSTR value = NULL;
1327     DWORD len = 0;
1328     UINT r;
1329
1330     TRACE("(%s, %s, %d, %s, %p, %p)\n", debugstr_a(szProductCode),
1331           debugstr_a(szUserSid), dwContext, debugstr_a(szProperty),
1332            szValue, pcchValue);
1333
1334     if (szValue && !pcchValue)
1335         return ERROR_INVALID_PARAMETER;
1336
1337     if (szProductCode) product = strdupAtoW(szProductCode);
1338     if (szUserSid) usersid = strdupAtoW(szUserSid);
1339     if (szProperty) property = strdupAtoW(szProperty);
1340
1341     r = MsiGetProductInfoExW(product, usersid, dwContext, property,
1342                              NULL, &len);
1343     if (r != ERROR_SUCCESS)
1344         goto done;
1345
1346     value = msi_alloc(++len * sizeof(WCHAR));
1347     if (!value)
1348     {
1349         r = ERROR_OUTOFMEMORY;
1350         goto done;
1351     }
1352
1353     r = MsiGetProductInfoExW(product, usersid, dwContext, property,
1354                              value, &len);
1355     if (r != ERROR_SUCCESS)
1356         goto done;
1357
1358     if (!pcchValue)
1359         goto done;
1360
1361     len = WideCharToMultiByte(CP_ACP, 0, value, -1, NULL, 0, NULL, NULL);
1362     if (*pcchValue >= len)
1363         WideCharToMultiByte(CP_ACP, 0, value, -1, szValue, len, NULL, NULL);
1364     else if (szValue)
1365     {
1366         r = ERROR_MORE_DATA;
1367         if (*pcchValue > 0)
1368             *szValue = '\0';
1369     }
1370
1371     if (*pcchValue <= len || !szValue)
1372         len = len * sizeof(WCHAR) - 1;
1373
1374     *pcchValue = len - 1;
1375
1376 done:
1377     msi_free(product);
1378     msi_free(usersid);
1379     msi_free(property);
1380     msi_free(value);
1381
1382     return r;
1383 }
1384
1385 static UINT msi_copy_outval(LPWSTR val, LPWSTR out, LPDWORD size)
1386 {
1387     UINT r = ERROR_SUCCESS;
1388
1389     if (!val)
1390         return ERROR_UNKNOWN_PROPERTY;
1391
1392     if (out)
1393     {
1394         if (strlenW(val) >= *size)
1395         {
1396             r = ERROR_MORE_DATA;
1397             if (*size > 0)
1398                 *out = '\0';
1399         }
1400         else
1401             lstrcpyW(out, val);
1402     }
1403
1404     if (size)
1405         *size = lstrlenW(val);
1406
1407     return r;
1408 }
1409
1410 UINT WINAPI MsiGetProductInfoExW(LPCWSTR szProductCode, LPCWSTR szUserSid,
1411                                  MSIINSTALLCONTEXT dwContext, LPCWSTR szProperty,
1412                                  LPWSTR szValue, LPDWORD pcchValue)
1413 {
1414     WCHAR squished_pc[GUID_SIZE];
1415     LPWSTR val = NULL;
1416     LPCWSTR package = NULL;
1417     HKEY props = NULL, prod;
1418     HKEY classes = NULL, managed;
1419     HKEY hkey = NULL;
1420     DWORD type;
1421     UINT r = ERROR_UNKNOWN_PRODUCT;
1422
1423     static const WCHAR five[] = {'5',0};
1424     static const WCHAR displayname[] = {
1425         'D','i','s','p','l','a','y','N','a','m','e',0};
1426     static const WCHAR displayversion[] = {
1427         'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0};
1428     static const WCHAR managed_local_package[] = {
1429         'M','a','n','a','g','e','d','L','o','c','a','l',
1430         'P','a','c','k','a','g','e',0};
1431
1432     TRACE("(%s, %s, %d, %s, %p, %p)\n", debugstr_w(szProductCode),
1433           debugstr_w(szUserSid), dwContext, debugstr_w(szProperty),
1434            szValue, pcchValue);
1435
1436     if (!szProductCode || !squash_guid(szProductCode, squished_pc))
1437         return ERROR_INVALID_PARAMETER;
1438
1439     if (szValue && !pcchValue)
1440         return ERROR_INVALID_PARAMETER;
1441
1442     if (dwContext != MSIINSTALLCONTEXT_USERUNMANAGED &&
1443         dwContext != MSIINSTALLCONTEXT_USERMANAGED &&
1444         dwContext != MSIINSTALLCONTEXT_MACHINE)
1445         return ERROR_INVALID_PARAMETER;
1446
1447     if (!szProperty || !*szProperty)
1448         return ERROR_INVALID_PARAMETER;
1449
1450     if (dwContext == MSIINSTALLCONTEXT_MACHINE && szUserSid)
1451         return ERROR_INVALID_PARAMETER;
1452
1453     /* FIXME: dwContext is provided, no need to search for it */
1454     MSIREG_OpenProductKey(szProductCode, NULL,MSIINSTALLCONTEXT_USERMANAGED,
1455                           &managed, FALSE);
1456     MSIREG_OpenProductKey(szProductCode, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
1457                           &prod, FALSE);
1458
1459     MSIREG_OpenInstallProps(szProductCode, dwContext, NULL, &props, FALSE);
1460
1461     if (dwContext == MSIINSTALLCONTEXT_USERUNMANAGED)
1462     {
1463         package = INSTALLPROPERTY_LOCALPACKAGEW;
1464
1465         if (!props && !prod)
1466             goto done;
1467     }
1468     else if (dwContext == MSIINSTALLCONTEXT_USERMANAGED)
1469     {
1470         package = managed_local_package;
1471
1472         if (!props && !managed)
1473             goto done;
1474     }
1475     else if (dwContext == MSIINSTALLCONTEXT_MACHINE)
1476     {
1477         package = INSTALLPROPERTY_LOCALPACKAGEW;
1478         MSIREG_OpenProductKey(szProductCode, NULL, dwContext, &classes, FALSE);
1479
1480         if (!props && !classes)
1481             goto done;
1482     }
1483
1484     if (!strcmpW( szProperty, INSTALLPROPERTY_HELPLINKW ) ||
1485         !strcmpW( szProperty, INSTALLPROPERTY_HELPTELEPHONEW ) ||
1486         !strcmpW( szProperty, INSTALLPROPERTY_INSTALLDATEW ) ||
1487         !strcmpW( szProperty, INSTALLPROPERTY_INSTALLEDPRODUCTNAMEW ) ||
1488         !strcmpW( szProperty, INSTALLPROPERTY_INSTALLLOCATIONW ) ||
1489         !strcmpW( szProperty, INSTALLPROPERTY_INSTALLSOURCEW ) ||
1490         !strcmpW( szProperty, INSTALLPROPERTY_LOCALPACKAGEW ) ||
1491         !strcmpW( szProperty, INSTALLPROPERTY_PUBLISHERW ) ||
1492         !strcmpW( szProperty, INSTALLPROPERTY_URLINFOABOUTW ) ||
1493         !strcmpW( szProperty, INSTALLPROPERTY_URLUPDATEINFOW ) ||
1494         !strcmpW( szProperty, INSTALLPROPERTY_VERSIONMINORW ) ||
1495         !strcmpW( szProperty, INSTALLPROPERTY_VERSIONMAJORW ) ||
1496         !strcmpW( szProperty, INSTALLPROPERTY_VERSIONSTRINGW ) ||
1497         !strcmpW( szProperty, INSTALLPROPERTY_PRODUCTIDW ) ||
1498         !strcmpW( szProperty, INSTALLPROPERTY_REGCOMPANYW ) ||
1499         !strcmpW( szProperty, INSTALLPROPERTY_REGOWNERW ) ||
1500         !strcmpW( szProperty, INSTALLPROPERTY_INSTANCETYPEW ))
1501     {
1502         val = msi_reg_get_value(props, package, &type);
1503         if (!val)
1504         {
1505             if (prod || classes)
1506                 r = ERROR_UNKNOWN_PROPERTY;
1507
1508             goto done;
1509         }
1510
1511         msi_free(val);
1512
1513         if (!strcmpW( szProperty, INSTALLPROPERTY_INSTALLEDPRODUCTNAMEW ))
1514             szProperty = displayname;
1515         else if (!strcmpW( szProperty, INSTALLPROPERTY_VERSIONSTRINGW ))
1516             szProperty = displayversion;
1517
1518         val = msi_reg_get_value(props, szProperty, &type);
1519         if (!val)
1520             val = strdupW(szEmpty);
1521
1522         r = msi_copy_outval(val, szValue, pcchValue);
1523     }
1524     else if (!strcmpW( szProperty, INSTALLPROPERTY_TRANSFORMSW ) ||
1525              !strcmpW( szProperty, INSTALLPROPERTY_LANGUAGEW ) ||
1526              !strcmpW( szProperty, INSTALLPROPERTY_PRODUCTNAMEW ) ||
1527              !strcmpW( szProperty, INSTALLPROPERTY_PACKAGECODEW ) ||
1528              !strcmpW( szProperty, INSTALLPROPERTY_VERSIONW ) ||
1529              !strcmpW( szProperty, INSTALLPROPERTY_PRODUCTICONW ) ||
1530              !strcmpW( szProperty, INSTALLPROPERTY_PACKAGENAMEW ) ||
1531              !strcmpW( szProperty, INSTALLPROPERTY_AUTHORIZED_LUA_APPW ))
1532     {
1533         if (!prod && !classes)
1534             goto done;
1535
1536         if (dwContext == MSIINSTALLCONTEXT_USERUNMANAGED)
1537             hkey = prod;
1538         else if (dwContext == MSIINSTALLCONTEXT_USERMANAGED)
1539             hkey = managed;
1540         else if (dwContext == MSIINSTALLCONTEXT_MACHINE)
1541             hkey = classes;
1542
1543         val = msi_reg_get_value(hkey, szProperty, &type);
1544         if (!val)
1545             val = strdupW(szEmpty);
1546
1547         r = msi_copy_outval(val, szValue, pcchValue);
1548     }
1549     else if (!strcmpW( szProperty, INSTALLPROPERTY_PRODUCTSTATEW ))
1550     {
1551         if (dwContext == MSIINSTALLCONTEXT_MACHINE)
1552         {
1553             if (props)
1554             {
1555                 val = msi_reg_get_value(props, package, &type);
1556                 if (!val)
1557                     goto done;
1558
1559                 msi_free(val);
1560                 val = strdupW(five);
1561             }
1562             else
1563                 val = strdupW(szOne);
1564
1565             r = msi_copy_outval(val, szValue, pcchValue);
1566             goto done;
1567         }
1568         else if (props && (val = msi_reg_get_value(props, package, &type)))
1569         {
1570             msi_free(val);
1571             val = strdupW(five);
1572             r = msi_copy_outval(val, szValue, pcchValue);
1573             goto done;
1574         }
1575
1576         if (prod || managed)
1577             val = strdupW(szOne);
1578         else
1579             goto done;
1580
1581         r = msi_copy_outval(val, szValue, pcchValue);
1582     }
1583     else if (!strcmpW( szProperty, INSTALLPROPERTY_ASSIGNMENTTYPEW ))
1584     {
1585         if (!prod && !classes)
1586             goto done;
1587
1588         /* FIXME */
1589         val = strdupW(szEmpty);
1590         r = msi_copy_outval(val, szValue, pcchValue);
1591     }
1592     else
1593         r = ERROR_UNKNOWN_PROPERTY;
1594
1595 done:
1596     RegCloseKey(props);
1597     RegCloseKey(prod);
1598     RegCloseKey(managed);
1599     RegCloseKey(classes);
1600     msi_free(val);
1601
1602     return r;
1603 }
1604
1605 UINT WINAPI MsiGetPatchInfoExA(LPCSTR szPatchCode, LPCSTR szProductCode,
1606                                LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext,
1607                                LPCSTR szProperty, LPSTR lpValue, DWORD *pcchValue)
1608 {
1609     LPWSTR patch = NULL, product = NULL, usersid = NULL;
1610     LPWSTR property = NULL, val = NULL;
1611     DWORD len;
1612     UINT r;
1613
1614     TRACE("(%s, %s, %s, %d, %s, %p, %p)\n", debugstr_a(szPatchCode),
1615           debugstr_a(szProductCode), debugstr_a(szUserSid), dwContext,
1616           debugstr_a(szProperty), lpValue, pcchValue);
1617
1618     if (lpValue && !pcchValue)
1619         return ERROR_INVALID_PARAMETER;
1620
1621     if (szPatchCode) patch = strdupAtoW(szPatchCode);
1622     if (szProductCode) product = strdupAtoW(szProductCode);
1623     if (szUserSid) usersid = strdupAtoW(szUserSid);
1624     if (szProperty) property = strdupAtoW(szProperty);
1625
1626     len = 0;
1627     r = MsiGetPatchInfoExW(patch, product, usersid, dwContext, property,
1628                            NULL, &len);
1629     if (r != ERROR_SUCCESS)
1630         goto done;
1631
1632     val = msi_alloc(++len * sizeof(WCHAR));
1633     if (!val)
1634     {
1635         r = ERROR_OUTOFMEMORY;
1636         goto done;
1637     }
1638
1639     r = MsiGetPatchInfoExW(patch, product, usersid, dwContext, property,
1640                            val, &len);
1641     if (r != ERROR_SUCCESS || !pcchValue)
1642         goto done;
1643
1644     if (lpValue)
1645         WideCharToMultiByte(CP_ACP, 0, val, -1, lpValue,
1646                             *pcchValue - 1, NULL, NULL);
1647
1648     len = lstrlenW(val);
1649     if ((*val && *pcchValue < len + 1) || !lpValue)
1650     {
1651         if (lpValue)
1652         {
1653             r = ERROR_MORE_DATA;
1654             lpValue[*pcchValue - 1] = '\0';
1655         }
1656
1657         *pcchValue = len * sizeof(WCHAR);
1658     }
1659     else
1660         *pcchValue = len;
1661
1662 done:
1663     msi_free(val);
1664     msi_free(patch);
1665     msi_free(product);
1666     msi_free(usersid);
1667     msi_free(property);
1668
1669     return r;
1670 }
1671
1672 UINT WINAPI MsiGetPatchInfoExW(LPCWSTR szPatchCode, LPCWSTR szProductCode,
1673                                LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext,
1674                                LPCWSTR szProperty, LPWSTR lpValue, DWORD *pcchValue)
1675 {
1676     WCHAR squished_pc[GUID_SIZE];
1677     WCHAR squished_patch[GUID_SIZE];
1678     HKEY udprod = 0, prod = 0, props = 0;
1679     HKEY patch = 0, patches = 0;
1680     HKEY udpatch = 0, datakey = 0;
1681     HKEY prodpatches = 0;
1682     LPWSTR val = NULL;
1683     UINT r = ERROR_UNKNOWN_PRODUCT;
1684     DWORD len;
1685     LONG res;
1686
1687     static const WCHAR szManagedPackage[] = {'M','a','n','a','g','e','d',
1688         'L','o','c','a','l','P','a','c','k','a','g','e',0};
1689
1690     TRACE("(%s, %s, %s, %d, %s, %p, %p)\n", debugstr_w(szPatchCode),
1691           debugstr_w(szProductCode), debugstr_w(szUserSid), dwContext,
1692           debugstr_w(szProperty), lpValue, pcchValue);
1693
1694     if (!szProductCode || !squash_guid(szProductCode, squished_pc))
1695         return ERROR_INVALID_PARAMETER;
1696
1697     if (!szPatchCode || !squash_guid(szPatchCode, squished_patch))
1698         return ERROR_INVALID_PARAMETER;
1699
1700     if (!szProperty)
1701         return ERROR_INVALID_PARAMETER;
1702
1703     if (lpValue && !pcchValue)
1704         return ERROR_INVALID_PARAMETER;
1705
1706     if (dwContext != MSIINSTALLCONTEXT_USERMANAGED &&
1707         dwContext != MSIINSTALLCONTEXT_USERUNMANAGED &&
1708         dwContext != MSIINSTALLCONTEXT_MACHINE)
1709         return ERROR_INVALID_PARAMETER;
1710
1711     if (dwContext == MSIINSTALLCONTEXT_MACHINE && szUserSid)
1712         return ERROR_INVALID_PARAMETER;
1713
1714     if (szUserSid && !strcmpW( szUserSid, szLocalSid ))
1715         return ERROR_INVALID_PARAMETER;
1716
1717     if (MSIREG_OpenUserDataProductKey(szProductCode, dwContext, NULL,
1718                                       &udprod, FALSE) != ERROR_SUCCESS)
1719         goto done;
1720
1721     if (MSIREG_OpenInstallProps(szProductCode, dwContext, NULL,
1722                                 &props, FALSE) != ERROR_SUCCESS)
1723         goto done;
1724
1725     r = ERROR_UNKNOWN_PATCH;
1726
1727     res = RegOpenKeyExW(udprod, szPatches, 0, KEY_WOW64_64KEY|KEY_READ, &patches);
1728     if (res != ERROR_SUCCESS)
1729         goto done;
1730
1731     res = RegOpenKeyExW(patches, squished_patch, 0, KEY_WOW64_64KEY|KEY_READ, &patch);
1732     if (res != ERROR_SUCCESS)
1733         goto done;
1734
1735     if (!strcmpW( szProperty, INSTALLPROPERTY_TRANSFORMSW ))
1736     {
1737         if (MSIREG_OpenProductKey(szProductCode, NULL, dwContext,
1738                                   &prod, FALSE) != ERROR_SUCCESS)
1739             goto done;
1740
1741         res = RegOpenKeyExW(prod, szPatches, 0, KEY_WOW64_64KEY|KEY_ALL_ACCESS, &prodpatches);
1742         if (res != ERROR_SUCCESS)
1743             goto done;
1744
1745         datakey = prodpatches;
1746         szProperty = squished_patch;
1747     }
1748     else
1749     {
1750         if (MSIREG_OpenUserDataPatchKey(szPatchCode, dwContext,
1751                                         &udpatch, FALSE) != ERROR_SUCCESS)
1752             goto done;
1753
1754         if (!strcmpW( szProperty, INSTALLPROPERTY_LOCALPACKAGEW ))
1755         {
1756             if (dwContext == MSIINSTALLCONTEXT_USERMANAGED)
1757                 szProperty = szManagedPackage;
1758             datakey = udpatch;
1759         }
1760         else if (!strcmpW( szProperty, INSTALLPROPERTY_INSTALLDATEW ))
1761         {
1762             datakey = patch;
1763             szProperty = szInstalled;
1764         }
1765         else if (!strcmpW( szProperty, INSTALLPROPERTY_LOCALPACKAGEW ))
1766         {
1767             datakey = udpatch;
1768         }
1769         else if (!strcmpW( szProperty, INSTALLPROPERTY_UNINSTALLABLEW ) ||
1770                  !strcmpW( szProperty, INSTALLPROPERTY_PATCHSTATEW ) ||
1771                  !strcmpW( szProperty, INSTALLPROPERTY_DISPLAYNAMEW ) ||
1772                  !strcmpW( szProperty, INSTALLPROPERTY_MOREINFOURLW ))
1773         {
1774             datakey = patch;
1775         }
1776         else
1777         {
1778             r = ERROR_UNKNOWN_PROPERTY;
1779             goto done;
1780         }
1781     }
1782
1783     val = msi_reg_get_val_str(datakey, szProperty);
1784     if (!val)
1785         val = strdupW(szEmpty);
1786
1787     r = ERROR_SUCCESS;
1788
1789     if (!pcchValue)
1790         goto done;
1791
1792     if (lpValue)
1793         lstrcpynW(lpValue, val, *pcchValue);
1794
1795     len = lstrlenW(val);
1796     if ((*val && *pcchValue < len + 1) || !lpValue)
1797     {
1798         if (lpValue)
1799             r = ERROR_MORE_DATA;
1800
1801         *pcchValue = len * sizeof(WCHAR);
1802     }
1803
1804     *pcchValue = len;
1805
1806 done:
1807     msi_free(val);
1808     RegCloseKey(prodpatches);
1809     RegCloseKey(prod);
1810     RegCloseKey(patch);
1811     RegCloseKey(patches);
1812     RegCloseKey(udpatch);
1813     RegCloseKey(props);
1814     RegCloseKey(udprod);
1815
1816     return r;
1817 }
1818
1819 UINT WINAPI MsiGetPatchInfoA( LPCSTR patch, LPCSTR attr, LPSTR buffer, LPDWORD buflen )
1820 {
1821     UINT r = ERROR_OUTOFMEMORY;
1822     DWORD size;
1823     LPWSTR patchW = NULL, attrW = NULL, bufferW = NULL;
1824
1825     TRACE("%s %s %p %p\n", debugstr_a(patch), debugstr_a(attr), buffer, buflen);
1826
1827     if (!patch || !attr)
1828         return ERROR_INVALID_PARAMETER;
1829
1830     if (!(patchW = strdupAtoW( patch )))
1831         goto done;
1832
1833     if (!(attrW = strdupAtoW( attr )))
1834         goto done;
1835
1836     size = 0;
1837     r = MsiGetPatchInfoW( patchW, attrW, NULL, &size );
1838     if (r != ERROR_SUCCESS)
1839         goto done;
1840
1841     size++;
1842     if (!(bufferW = msi_alloc( size * sizeof(WCHAR) )))
1843     {
1844         r = ERROR_OUTOFMEMORY;
1845         goto done;
1846     }
1847
1848     r = MsiGetPatchInfoW( patchW, attrW, bufferW, &size );
1849     if (r == ERROR_SUCCESS)
1850     {
1851         int len = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );
1852         if (len > *buflen)
1853             r = ERROR_MORE_DATA;
1854         else if (buffer)
1855             WideCharToMultiByte( CP_ACP, 0, bufferW, -1, buffer, *buflen, NULL, NULL );
1856
1857         *buflen = len - 1;
1858     }
1859
1860 done:
1861     msi_free( patchW );
1862     msi_free( attrW );
1863     msi_free( bufferW );
1864     return r;
1865 }
1866
1867 UINT WINAPI MsiGetPatchInfoW( LPCWSTR patch, LPCWSTR attr, LPWSTR buffer, LPDWORD buflen )
1868 {
1869     UINT r;
1870     WCHAR product[GUID_SIZE];
1871     DWORD index;
1872
1873     TRACE("%s %s %p %p\n", debugstr_w(patch), debugstr_w(attr), buffer, buflen);
1874
1875     if (!patch || !attr)
1876         return ERROR_INVALID_PARAMETER;
1877
1878     if (strcmpW( INSTALLPROPERTY_LOCALPACKAGEW, attr ))
1879         return ERROR_UNKNOWN_PROPERTY;
1880
1881     index = 0;
1882     while (1)
1883     {
1884         r = MsiEnumProductsW( index, product );
1885         if (r != ERROR_SUCCESS)
1886             break;
1887
1888         r = MsiGetPatchInfoExW( patch, product, NULL, MSIINSTALLCONTEXT_USERMANAGED, attr, buffer, buflen );
1889         if (r == ERROR_SUCCESS || r == ERROR_MORE_DATA)
1890             return r;
1891
1892         r = MsiGetPatchInfoExW( patch, product, NULL, MSIINSTALLCONTEXT_USERUNMANAGED, attr, buffer, buflen );
1893         if (r == ERROR_SUCCESS || r == ERROR_MORE_DATA)
1894             return r;
1895
1896         r = MsiGetPatchInfoExW( patch, product, NULL, MSIINSTALLCONTEXT_MACHINE, attr, buffer, buflen );
1897         if (r == ERROR_SUCCESS || r == ERROR_MORE_DATA)
1898             return r;
1899
1900         index++;
1901     }
1902
1903     return ERROR_UNKNOWN_PRODUCT;
1904 }
1905
1906 UINT WINAPI MsiEnableLogA(DWORD dwLogMode, LPCSTR szLogFile, DWORD attributes)
1907 {
1908     LPWSTR szwLogFile = NULL;
1909     UINT r;
1910
1911     TRACE("%08x %s %08x\n", dwLogMode, debugstr_a(szLogFile), attributes);
1912
1913     if( szLogFile )
1914     {
1915         szwLogFile = strdupAtoW( szLogFile );
1916         if( !szwLogFile )
1917             return ERROR_OUTOFMEMORY;
1918     }
1919     r = MsiEnableLogW( dwLogMode, szwLogFile, attributes );
1920     msi_free( szwLogFile );
1921     return r;
1922 }
1923
1924 UINT WINAPI MsiEnableLogW(DWORD dwLogMode, LPCWSTR szLogFile, DWORD attributes)
1925 {
1926     TRACE("%08x %s %08x\n", dwLogMode, debugstr_w(szLogFile), attributes);
1927
1928     msi_free(gszLogFile);
1929     gszLogFile = NULL;
1930     if (szLogFile)
1931     {
1932         HANDLE file;
1933
1934         if (!(attributes & INSTALLLOGATTRIBUTES_APPEND))
1935             DeleteFileW(szLogFile);
1936         file = CreateFileW(szLogFile, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_ALWAYS,
1937                            FILE_ATTRIBUTE_NORMAL, NULL);
1938         if (file != INVALID_HANDLE_VALUE)
1939         {
1940             gszLogFile = strdupW(szLogFile);
1941             CloseHandle(file);
1942         }
1943         else
1944             ERR("Unable to enable log %s (%u)\n", debugstr_w(szLogFile), GetLastError());
1945     }
1946
1947     return ERROR_SUCCESS;
1948 }
1949
1950 UINT WINAPI MsiEnumComponentCostsA( MSIHANDLE handle, LPCSTR component, DWORD index,
1951                                     INSTALLSTATE state, LPSTR drive, DWORD *buflen,
1952                                     int *cost, int *temp )
1953 {
1954     UINT r;
1955     DWORD len;
1956     WCHAR *driveW, *componentW = NULL;
1957
1958     TRACE("%d, %s, %u, %d, %p, %p, %p %p\n", handle, debugstr_a(component), index,
1959           state, drive, buflen, cost, temp);
1960
1961     if (!drive || !buflen) return ERROR_INVALID_PARAMETER;
1962     if (component && !(componentW = strdupAtoW( component ))) return ERROR_OUTOFMEMORY;
1963
1964     len = *buflen;
1965     if (!(driveW = msi_alloc( len * sizeof(WCHAR) )))
1966     {
1967         msi_free( componentW );
1968         return ERROR_OUTOFMEMORY;
1969     }
1970     r = MsiEnumComponentCostsW( handle, componentW, index, state, driveW, buflen, cost, temp );
1971     if (!r)
1972     {
1973         WideCharToMultiByte( CP_ACP, 0, driveW, -1, drive, len, NULL, NULL );
1974     }
1975     msi_free( componentW );
1976     msi_free( driveW );
1977     return r;
1978 }
1979
1980 static UINT set_drive( WCHAR *buffer, WCHAR letter )
1981 {
1982     buffer[0] = letter;
1983     buffer[1] = ':';
1984     buffer[2] = 0;
1985     return 2;
1986 }
1987
1988 UINT WINAPI MsiEnumComponentCostsW( MSIHANDLE handle, LPCWSTR component, DWORD index,
1989                                     INSTALLSTATE state, LPWSTR drive, DWORD *buflen,
1990                                     int *cost, int *temp )
1991 {
1992     UINT r = ERROR_NO_MORE_ITEMS;
1993     MSICOMPONENT *comp = NULL;
1994     MSIPACKAGE *package;
1995     MSIFILE *file;
1996     STATSTG stat = {0};
1997     WCHAR path[MAX_PATH];
1998
1999     TRACE("%d, %s, %u, %d, %p, %p, %p %p\n", handle, debugstr_w(component), index,
2000           state, drive, buflen, cost, temp);
2001
2002     if (!drive || !buflen || !cost || !temp) return ERROR_INVALID_PARAMETER;
2003     if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE )))
2004     {
2005         HRESULT hr;
2006         IWineMsiRemotePackage *remote_package;
2007         BSTR bname = NULL;
2008
2009         if (!(remote_package = (IWineMsiRemotePackage *)msi_get_remote( handle )))
2010             return ERROR_INVALID_HANDLE;
2011
2012         if (component && !(bname = SysAllocString( component )))
2013         {
2014             IWineMsiRemotePackage_Release( remote_package );
2015             return ERROR_OUTOFMEMORY;
2016         }
2017         hr = IWineMsiRemotePackage_EnumComponentCosts( remote_package, bname, index, state, drive, buflen, cost, temp );
2018         IWineMsiRemotePackage_Release( remote_package );
2019         SysFreeString( bname );
2020         if (FAILED(hr))
2021         {
2022             if (HRESULT_FACILITY(hr) == FACILITY_WIN32) return HRESULT_CODE(hr);
2023             return ERROR_FUNCTION_FAILED;
2024         }
2025         return ERROR_SUCCESS;
2026     }
2027
2028     if (!msi_get_property_int( package->db, szCostingComplete, 0 ))
2029     {
2030         msiobj_release( &package->hdr );
2031         return ERROR_FUNCTION_NOT_CALLED;
2032     }
2033     if (component && component[0] && !(comp = msi_get_loaded_component( package, component )))
2034     {
2035         msiobj_release( &package->hdr );
2036         return ERROR_UNKNOWN_COMPONENT;
2037     }
2038     if (*buflen < 3)
2039     {
2040         *buflen = 2;
2041         msiobj_release( &package->hdr );
2042         return ERROR_MORE_DATA;
2043     }
2044     if (index)
2045     {
2046         msiobj_release( &package->hdr );
2047         return ERROR_NO_MORE_ITEMS;
2048     }
2049
2050     drive[0] = 0;
2051     *cost = *temp = 0;
2052     GetWindowsDirectoryW( path, MAX_PATH );
2053     if (component && component[0])
2054     {
2055         if (comp->assembly && !comp->assembly->application) *temp = comp->Cost;
2056         if (!comp->Enabled || !comp->KeyPath)
2057         {
2058             *cost = 0;
2059             *buflen = set_drive( drive, path[0] );
2060             r = ERROR_SUCCESS;
2061         }
2062         else if ((file = msi_get_loaded_file( package, comp->KeyPath )))
2063         {
2064             *cost = max( 8, comp->Cost / 512 );
2065             *buflen = set_drive( drive, file->TargetPath[0] );
2066             r = ERROR_SUCCESS;
2067         }
2068     }
2069     else if (IStorage_Stat( package->db->storage, &stat, STATFLAG_NONAME ) == S_OK)
2070     {
2071         *temp = max( 8, stat.cbSize.QuadPart / 512 );
2072         *buflen = set_drive( drive, path[0] );
2073         r = ERROR_SUCCESS;
2074     }
2075     msiobj_release( &package->hdr );
2076     return r;
2077 }
2078
2079 UINT WINAPI MsiQueryComponentStateA(LPCSTR szProductCode,
2080                                     LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext,
2081                                     LPCSTR szComponent, INSTALLSTATE *pdwState)
2082 {
2083     LPWSTR prodcode = NULL, usersid = NULL, comp = NULL;
2084     UINT r;
2085
2086     TRACE("(%s, %s, %d, %s, %p)\n", debugstr_a(szProductCode),
2087           debugstr_a(szUserSid), dwContext, debugstr_a(szComponent), pdwState);
2088
2089     if (szProductCode && !(prodcode = strdupAtoW(szProductCode)))
2090         return ERROR_OUTOFMEMORY;
2091
2092     if (szUserSid && !(usersid = strdupAtoW(szUserSid)))
2093             return ERROR_OUTOFMEMORY;
2094
2095     if (szComponent && !(comp = strdupAtoW(szComponent)))
2096             return ERROR_OUTOFMEMORY;
2097
2098     r = MsiQueryComponentStateW(prodcode, usersid, dwContext, comp, pdwState);
2099
2100     msi_free(prodcode);
2101     msi_free(usersid);
2102     msi_free(comp);
2103
2104     return r;
2105 }
2106
2107 static BOOL msi_comp_find_prod_key(LPCWSTR prodcode, MSIINSTALLCONTEXT context)
2108 {
2109     UINT r;
2110     HKEY hkey = NULL;
2111
2112     r = MSIREG_OpenProductKey(prodcode, NULL, context, &hkey, FALSE);
2113     RegCloseKey(hkey);
2114     return (r == ERROR_SUCCESS);
2115 }
2116
2117 static BOOL msi_comp_find_package(LPCWSTR prodcode, MSIINSTALLCONTEXT context)
2118 {
2119     LPCWSTR package;
2120     HKEY hkey;
2121     DWORD sz;
2122     LONG res;
2123     UINT r;
2124
2125     static const WCHAR local_package[] = {'L','o','c','a','l','P','a','c','k','a','g','e',0};
2126     static const WCHAR managed_local_package[] = {
2127         'M','a','n','a','g','e','d','L','o','c','a','l','P','a','c','k','a','g','e',0
2128     };
2129
2130     r = MSIREG_OpenInstallProps(prodcode, context, NULL, &hkey, FALSE);
2131     if (r != ERROR_SUCCESS)
2132         return FALSE;
2133
2134     if (context == MSIINSTALLCONTEXT_USERMANAGED)
2135         package = managed_local_package;
2136     else
2137         package = local_package;
2138
2139     sz = 0;
2140     res = RegQueryValueExW(hkey, package, NULL, NULL, NULL, &sz);
2141     RegCloseKey(hkey);
2142
2143     return (res == ERROR_SUCCESS);
2144 }
2145
2146 static UINT msi_comp_find_prodcode(LPWSTR squished_pc,
2147                                    MSIINSTALLCONTEXT context,
2148                                    LPCWSTR comp, LPWSTR val, DWORD *sz)
2149 {
2150     HKEY hkey;
2151     LONG res;
2152     UINT r;
2153
2154     if (context == MSIINSTALLCONTEXT_MACHINE)
2155         r = MSIREG_OpenUserDataComponentKey(comp, szLocalSid, &hkey, FALSE);
2156     else
2157         r = MSIREG_OpenUserDataComponentKey(comp, NULL, &hkey, FALSE);
2158
2159     if (r != ERROR_SUCCESS)
2160         return r;
2161
2162     res = RegQueryValueExW(hkey, squished_pc, NULL, NULL, (BYTE *)val, sz);
2163     if (res != ERROR_SUCCESS)
2164         return res;
2165
2166     RegCloseKey(hkey);
2167     return res;
2168 }
2169
2170 UINT WINAPI MsiQueryComponentStateW(LPCWSTR szProductCode,
2171                                     LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext,
2172                                     LPCWSTR szComponent, INSTALLSTATE *pdwState)
2173 {
2174     WCHAR squished_pc[GUID_SIZE];
2175     BOOL found;
2176     DWORD sz;
2177
2178     TRACE("(%s, %s, %d, %s, %p)\n", debugstr_w(szProductCode),
2179           debugstr_w(szUserSid), dwContext, debugstr_w(szComponent), pdwState);
2180
2181     if (!pdwState || !szComponent)
2182         return ERROR_INVALID_PARAMETER;
2183
2184     if (!szProductCode || !*szProductCode || lstrlenW(szProductCode) != GUID_SIZE - 1)
2185         return ERROR_INVALID_PARAMETER;
2186
2187     if (!squash_guid(szProductCode, squished_pc))
2188         return ERROR_INVALID_PARAMETER;
2189
2190     found = msi_comp_find_prod_key(szProductCode, dwContext);
2191
2192     if (!msi_comp_find_package(szProductCode, dwContext))
2193     {
2194         if (found)
2195         {
2196             *pdwState = INSTALLSTATE_UNKNOWN;
2197             return ERROR_UNKNOWN_COMPONENT;
2198         }
2199
2200         return ERROR_UNKNOWN_PRODUCT;
2201     }
2202
2203     *pdwState = INSTALLSTATE_UNKNOWN;
2204
2205     sz = 0;
2206     if (msi_comp_find_prodcode(squished_pc, dwContext, szComponent, NULL, &sz))
2207         return ERROR_UNKNOWN_COMPONENT;
2208
2209     if (sz == 0)
2210         *pdwState = INSTALLSTATE_NOTUSED;
2211     else
2212     {
2213         WCHAR *val;
2214         UINT r;
2215
2216         if (!(val = msi_alloc( sz ))) return ERROR_OUTOFMEMORY;
2217         if ((r = msi_comp_find_prodcode(squished_pc, dwContext, szComponent, val, &sz)))
2218         {
2219             msi_free(val);
2220             return r;
2221         }
2222
2223         if (lstrlenW(val) > 2 &&
2224             val[0] >= '0' && val[0] <= '9' && val[1] >= '0' && val[1] <= '9' && val[2] != ':')
2225         {
2226             *pdwState = INSTALLSTATE_SOURCE;
2227         }
2228         else
2229             *pdwState = INSTALLSTATE_LOCAL;
2230         msi_free( val );
2231     }
2232
2233     TRACE("-> %d\n", *pdwState);
2234     return ERROR_SUCCESS;
2235 }
2236
2237 INSTALLSTATE WINAPI MsiQueryProductStateA(LPCSTR szProduct)
2238 {
2239     LPWSTR szwProduct = NULL;
2240     INSTALLSTATE r;
2241
2242     if( szProduct )
2243     {
2244          szwProduct = strdupAtoW( szProduct );
2245          if( !szwProduct )
2246              return ERROR_OUTOFMEMORY;
2247     }
2248     r = MsiQueryProductStateW( szwProduct );
2249     msi_free( szwProduct );
2250     return r;
2251 }
2252
2253 INSTALLSTATE WINAPI MsiQueryProductStateW(LPCWSTR szProduct)
2254 {
2255     MSIINSTALLCONTEXT context = MSIINSTALLCONTEXT_USERUNMANAGED;
2256     INSTALLSTATE state = INSTALLSTATE_ADVERTISED;
2257     HKEY prodkey = 0, userdata = 0;
2258     DWORD val;
2259     UINT r;
2260
2261     TRACE("%s\n", debugstr_w(szProduct));
2262
2263     if (!szProduct || !*szProduct)
2264         return INSTALLSTATE_INVALIDARG;
2265
2266     if (lstrlenW(szProduct) != GUID_SIZE - 1)
2267         return INSTALLSTATE_INVALIDARG;
2268
2269     if (szProduct[0] != '{' || szProduct[37] != '}')
2270         return INSTALLSTATE_UNKNOWN;
2271
2272     SetLastError( ERROR_SUCCESS );
2273
2274     if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
2275                               &prodkey, FALSE) != ERROR_SUCCESS &&
2276         MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2277                               &prodkey, FALSE) != ERROR_SUCCESS &&
2278         MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
2279                               &prodkey, FALSE) == ERROR_SUCCESS)
2280     {
2281         context = MSIINSTALLCONTEXT_MACHINE;
2282     }
2283
2284     r = MSIREG_OpenInstallProps(szProduct, context, NULL, &userdata, FALSE);
2285     if (r != ERROR_SUCCESS)
2286         goto done;
2287
2288     if (!msi_reg_get_val_dword(userdata, szWindowsInstaller, &val))
2289         goto done;
2290
2291     if (val)
2292         state = INSTALLSTATE_DEFAULT;
2293     else
2294         state = INSTALLSTATE_UNKNOWN;
2295
2296 done:
2297     if (!prodkey)
2298     {
2299         state = INSTALLSTATE_UNKNOWN;
2300
2301         if (userdata)
2302             state = INSTALLSTATE_ABSENT;
2303     }
2304
2305     RegCloseKey(prodkey);
2306     RegCloseKey(userdata);
2307     TRACE("-> %d\n", state);
2308     return state;
2309 }
2310
2311 INSTALLUILEVEL WINAPI MsiSetInternalUI(INSTALLUILEVEL dwUILevel, HWND *phWnd)
2312 {
2313     INSTALLUILEVEL old = gUILevel;
2314     HWND oldwnd = gUIhwnd;
2315
2316     TRACE("%08x %p\n", dwUILevel, phWnd);
2317
2318     gUILevel = dwUILevel;
2319     if (phWnd)
2320     {
2321         gUIhwnd = *phWnd;
2322         *phWnd = oldwnd;
2323     }
2324     return old;
2325 }
2326
2327 INSTALLUI_HANDLERA WINAPI MsiSetExternalUIA(INSTALLUI_HANDLERA puiHandler,
2328                                   DWORD dwMessageFilter, LPVOID pvContext)
2329 {
2330     INSTALLUI_HANDLERA prev = gUIHandlerA;
2331
2332     TRACE("%p %08x %p\n", puiHandler, dwMessageFilter, pvContext);
2333
2334     gUIHandlerA = puiHandler;
2335     gUIHandlerW = NULL;
2336     gUIFilter   = dwMessageFilter;
2337     gUIContext  = pvContext;
2338
2339     return prev;
2340 }
2341
2342 INSTALLUI_HANDLERW WINAPI MsiSetExternalUIW(INSTALLUI_HANDLERW puiHandler,
2343                                   DWORD dwMessageFilter, LPVOID pvContext)
2344 {
2345     INSTALLUI_HANDLERW prev = gUIHandlerW;
2346
2347     TRACE("%p %08x %p\n", puiHandler, dwMessageFilter, pvContext);
2348
2349     gUIHandlerA = NULL;
2350     gUIHandlerW = puiHandler;
2351     gUIFilter   = dwMessageFilter;
2352     gUIContext  = pvContext;
2353
2354     return prev;
2355 }
2356
2357 /******************************************************************
2358  *  MsiLoadStringW            [MSI.@]
2359  *
2360  * Loads a string from MSI's string resources.
2361  *
2362  * PARAMS
2363  *
2364  *   handle        [I]  only -1 is handled currently
2365  *   id            [I]  id of the string to be loaded
2366  *   lpBuffer      [O]  buffer for the string to be written to
2367  *   nBufferMax    [I]  maximum size of the buffer in characters
2368  *   lang          [I]  the preferred language for the string
2369  *
2370  * RETURNS
2371  *
2372  *   If successful, this function returns the language id of the string loaded
2373  *   If the function fails, the function returns zero.
2374  *
2375  * NOTES
2376  *
2377  *   The type of the first parameter is unknown.  LoadString's prototype
2378  *  suggests that it might be a module handle.  I have made it an MSI handle
2379  *  for starters, as -1 is an invalid MSI handle, but not an invalid module
2380  *  handle.  Maybe strings can be stored in an MSI database somehow.
2381  */
2382 LANGID WINAPI MsiLoadStringW( MSIHANDLE handle, UINT id, LPWSTR lpBuffer,
2383                 int nBufferMax, LANGID lang )
2384 {
2385     HRSRC hres;
2386     HGLOBAL hResData;
2387     LPWSTR p;
2388     DWORD i, len;
2389
2390     TRACE("%d %u %p %d %d\n", handle, id, lpBuffer, nBufferMax, lang);
2391
2392     if( handle != -1 )
2393         FIXME("don't know how to deal with handle = %08x\n", handle);
2394
2395     if( !lang )
2396         lang = GetUserDefaultLangID();
2397
2398     hres = FindResourceExW( msi_hInstance, (LPCWSTR) RT_STRING,
2399                             (LPWSTR)1, lang );
2400     if( !hres )
2401         return 0;
2402     hResData = LoadResource( msi_hInstance, hres );
2403     if( !hResData )
2404         return 0;
2405     p = LockResource( hResData );
2406     if( !p )
2407         return 0;
2408
2409     for (i = 0; i < (id & 0xf); i++) p += *p + 1;
2410     len = *p;
2411
2412     if( nBufferMax <= len )
2413         return 0;
2414
2415     memcpy( lpBuffer, p+1, len * sizeof(WCHAR));
2416     lpBuffer[ len ] = 0;
2417
2418     TRACE("found -> %s\n", debugstr_w(lpBuffer));
2419     return lang;
2420 }
2421
2422 LANGID WINAPI MsiLoadStringA( MSIHANDLE handle, UINT id, LPSTR lpBuffer,
2423                 int nBufferMax, LANGID lang )
2424 {
2425     LPWSTR bufW;
2426     LANGID r;
2427     INT len;
2428
2429     bufW = msi_alloc(nBufferMax*sizeof(WCHAR));
2430     r = MsiLoadStringW(handle, id, bufW, nBufferMax, lang);
2431     if( r )
2432     {
2433         len = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL, NULL );
2434         if( len <= nBufferMax )
2435             WideCharToMultiByte( CP_ACP, 0, bufW, -1,
2436                                  lpBuffer, nBufferMax, NULL, NULL );
2437         else
2438             r = 0;
2439     }
2440     msi_free(bufW);
2441     return r;
2442 }
2443
2444 INSTALLSTATE WINAPI MsiLocateComponentA(LPCSTR szComponent, LPSTR lpPathBuf,
2445                 LPDWORD pcchBuf)
2446 {
2447     char szProduct[GUID_SIZE];
2448
2449     TRACE("%s %p %p\n", debugstr_a(szComponent), lpPathBuf, pcchBuf);
2450
2451     if (!szComponent || !pcchBuf)
2452         return INSTALLSTATE_INVALIDARG;
2453
2454     if (MsiGetProductCodeA( szComponent, szProduct ) != ERROR_SUCCESS)
2455         return INSTALLSTATE_UNKNOWN;
2456
2457     return MsiGetComponentPathA( szProduct, szComponent, lpPathBuf, pcchBuf );
2458 }
2459
2460 INSTALLSTATE WINAPI MsiLocateComponentW(LPCWSTR szComponent, LPWSTR lpPathBuf,
2461                 LPDWORD pcchBuf)
2462 {
2463     WCHAR szProduct[GUID_SIZE];
2464
2465     TRACE("%s %p %p\n", debugstr_w(szComponent), lpPathBuf, pcchBuf);
2466
2467     if (!szComponent || !pcchBuf)
2468         return INSTALLSTATE_INVALIDARG;
2469
2470     if (MsiGetProductCodeW( szComponent, szProduct ) != ERROR_SUCCESS)
2471         return INSTALLSTATE_UNKNOWN;
2472
2473     return MsiGetComponentPathW( szProduct, szComponent, lpPathBuf, pcchBuf );
2474 }
2475
2476 UINT WINAPI MsiMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,
2477                 WORD wLanguageId, DWORD f)
2478 {
2479     FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_a(lpText), debugstr_a(lpCaption),
2480           uType, wLanguageId, f);
2481     return MessageBoxExA(hWnd,lpText,lpCaption,uType,wLanguageId);
2482 }
2483
2484 UINT WINAPI MsiMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,
2485                 WORD wLanguageId, DWORD f)
2486 {
2487     FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_w(lpText), debugstr_w(lpCaption),
2488           uType, wLanguageId, f);
2489     return MessageBoxExW(hWnd,lpText,lpCaption,uType,wLanguageId);
2490 }
2491
2492 UINT WINAPI MsiMessageBoxExA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,
2493                 DWORD unknown, WORD wLanguageId, DWORD f)
2494 {
2495     FIXME("(%p, %s, %s, %u, 0x%08x, 0x%08x, 0x%08x): semi-stub\n", hWnd, debugstr_a(lpText),
2496             debugstr_a(lpCaption), uType, unknown, wLanguageId, f);
2497     return MessageBoxExA(hWnd, lpText, lpCaption, uType, wLanguageId);
2498 }
2499
2500 UINT WINAPI MsiMessageBoxExW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,
2501                 DWORD unknown, WORD wLanguageId, DWORD f)
2502 {
2503     FIXME("(%p, %s, %s, %u, 0x%08x, 0x%08x, 0x%08x): semi-stub\n", hWnd, debugstr_w(lpText),
2504             debugstr_w(lpCaption), uType, unknown, wLanguageId, f);
2505     return MessageBoxExW(hWnd, lpText, lpCaption, uType, wLanguageId);
2506 }
2507
2508 UINT WINAPI MsiProvideAssemblyA( LPCSTR szAssemblyName, LPCSTR szAppContext,
2509                 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPSTR lpPathBuf,
2510                 LPDWORD pcchPathBuf )
2511 {
2512     FIXME("%s %s %08x %08x %p %p\n", debugstr_a(szAssemblyName),
2513           debugstr_a(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
2514           pcchPathBuf);
2515     return ERROR_CALL_NOT_IMPLEMENTED;
2516 }
2517
2518 UINT WINAPI MsiProvideAssemblyW( LPCWSTR szAssemblyName, LPCWSTR szAppContext,
2519                 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPWSTR lpPathBuf,
2520                 LPDWORD pcchPathBuf )
2521 {
2522     FIXME("%s %s %08x %08x %p %p\n", debugstr_w(szAssemblyName),
2523           debugstr_w(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
2524           pcchPathBuf);
2525     return ERROR_CALL_NOT_IMPLEMENTED;
2526 }
2527
2528 UINT WINAPI MsiProvideComponentFromDescriptorA( LPCSTR szDescriptor,
2529                 LPSTR szPath, LPDWORD pcchPath, LPDWORD pcchArgs )
2530 {
2531     FIXME("%s %p %p %p\n", debugstr_a(szDescriptor), szPath, pcchPath, pcchArgs );
2532     return ERROR_CALL_NOT_IMPLEMENTED;
2533 }
2534
2535 UINT WINAPI MsiProvideComponentFromDescriptorW( LPCWSTR szDescriptor,
2536                 LPWSTR szPath, LPDWORD pcchPath, LPDWORD pcchArgs )
2537 {
2538     FIXME("%s %p %p %p\n", debugstr_w(szDescriptor), szPath, pcchPath, pcchArgs );
2539     return ERROR_CALL_NOT_IMPLEMENTED;
2540 }
2541
2542 HRESULT WINAPI MsiGetFileSignatureInformationA( LPCSTR path, DWORD flags, PCCERT_CONTEXT *cert,
2543                                                 LPBYTE hash, LPDWORD hashlen )
2544 {
2545     UINT r;
2546     WCHAR *pathW = NULL;
2547
2548     TRACE("%s %08x %p %p %p\n", debugstr_a(path), flags, cert, hash, hashlen);
2549
2550     if (path && !(pathW = strdupAtoW( path ))) return ERROR_OUTOFMEMORY;
2551     r = MsiGetFileSignatureInformationW( pathW, flags, cert, hash, hashlen );
2552     msi_free( pathW );
2553     return r;
2554 }
2555
2556 HRESULT WINAPI MsiGetFileSignatureInformationW( LPCWSTR path, DWORD flags, PCCERT_CONTEXT *cert,
2557                                                 LPBYTE hash, LPDWORD hashlen )
2558 {
2559     static GUID generic_verify_v2 = WINTRUST_ACTION_GENERIC_VERIFY_V2;
2560     HRESULT hr;
2561     WINTRUST_DATA data;
2562     WINTRUST_FILE_INFO info;
2563     CRYPT_PROVIDER_SGNR *signer;
2564     CRYPT_PROVIDER_CERT *provider;
2565
2566     TRACE("%s %08x %p %p %p\n", debugstr_w(path), flags, cert, hash, hashlen);
2567
2568     if (!path || !cert) return E_INVALIDARG;
2569
2570     info.cbStruct       = sizeof(info);
2571     info.pcwszFilePath  = path;
2572     info.hFile          = NULL;
2573     info.pgKnownSubject = NULL;
2574
2575     data.cbStruct            = sizeof(data);
2576     data.pPolicyCallbackData = NULL;
2577     data.pSIPClientData      = NULL;
2578     data.dwUIChoice          = WTD_UI_NONE;
2579     data.fdwRevocationChecks = WTD_REVOKE_WHOLECHAIN;
2580     data.dwUnionChoice       = WTD_CHOICE_FILE;
2581     data.u.pFile             = &info;
2582     data.dwStateAction       = WTD_STATEACTION_VERIFY;
2583     data.hWVTStateData       = NULL;
2584     data.pwszURLReference    = NULL;
2585     data.dwProvFlags         = 0;
2586     data.dwUIContext         = WTD_UICONTEXT_INSTALL;
2587     hr = WinVerifyTrustEx( INVALID_HANDLE_VALUE, &generic_verify_v2, &data );
2588     *cert = NULL;
2589     if (FAILED(hr)) goto done;
2590
2591     if (!(signer = WTHelperGetProvSignerFromChain( data.hWVTStateData, 0, FALSE, 0 )))
2592     {
2593         hr = TRUST_E_NOSIGNATURE;
2594         goto done;
2595     }
2596     if (hash)
2597     {
2598         DWORD len = signer->psSigner->EncryptedHash.cbData;
2599         if (*hashlen < len)
2600         {
2601             *hashlen = len;
2602             hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA);
2603             goto done;
2604         }
2605         memcpy( hash, signer->psSigner->EncryptedHash.pbData, len );
2606         *hashlen = len;
2607     }
2608     if (!(provider = WTHelperGetProvCertFromChain( signer, 0 )))
2609     {
2610         hr = TRUST_E_PROVIDER_UNKNOWN;
2611         goto done;
2612     }
2613     *cert = CertDuplicateCertificateContext( provider->pCert );
2614
2615 done:
2616     data.dwStateAction = WTD_STATEACTION_CLOSE;
2617     WinVerifyTrustEx( INVALID_HANDLE_VALUE, &generic_verify_v2, &data );
2618     return hr;
2619 }
2620
2621 /******************************************************************
2622  * MsiGetProductPropertyA      [MSI.@]
2623  */
2624 UINT WINAPI MsiGetProductPropertyA(MSIHANDLE hProduct, LPCSTR szProperty,
2625                                    LPSTR szValue, LPDWORD pccbValue)
2626 {
2627     LPWSTR prop = NULL, val = NULL;
2628     DWORD len;
2629     UINT r;
2630
2631     TRACE("(%d, %s, %p, %p)\n", hProduct, debugstr_a(szProperty),
2632           szValue, pccbValue);
2633
2634     if (szValue && !pccbValue)
2635         return ERROR_INVALID_PARAMETER;
2636
2637     if (szProperty) prop = strdupAtoW(szProperty);
2638
2639     len = 0;
2640     r = MsiGetProductPropertyW(hProduct, prop, NULL, &len);
2641     if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
2642         goto done;
2643
2644     if (r == ERROR_SUCCESS)
2645     {
2646         if (szValue) *szValue = '\0';
2647         if (pccbValue) *pccbValue = 0;
2648         goto done;
2649     }
2650
2651     val = msi_alloc(++len * sizeof(WCHAR));
2652     if (!val)
2653     {
2654         r = ERROR_OUTOFMEMORY;
2655         goto done;
2656     }
2657
2658     r = MsiGetProductPropertyW(hProduct, prop, val, &len);
2659     if (r != ERROR_SUCCESS)
2660         goto done;
2661
2662     len = WideCharToMultiByte(CP_ACP, 0, val, -1, NULL, 0, NULL, NULL);
2663
2664     if (szValue)
2665         WideCharToMultiByte(CP_ACP, 0, val, -1, szValue,
2666                             *pccbValue, NULL, NULL);
2667
2668     if (pccbValue)
2669     {
2670         if (len > *pccbValue)
2671             r = ERROR_MORE_DATA;
2672
2673         *pccbValue = len - 1;
2674     }
2675
2676 done:
2677     msi_free(prop);
2678     msi_free(val);
2679
2680     return r;
2681 }
2682
2683 /******************************************************************
2684  * MsiGetProductPropertyW      [MSI.@]
2685  */
2686 UINT WINAPI MsiGetProductPropertyW(MSIHANDLE hProduct, LPCWSTR szProperty,
2687                                    LPWSTR szValue, LPDWORD pccbValue)
2688 {
2689     MSIPACKAGE *package;
2690     MSIQUERY *view = NULL;
2691     MSIRECORD *rec = NULL;
2692     LPCWSTR val;
2693     UINT r;
2694
2695     static const WCHAR query[] = {
2696        'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2697        '`','P','r','o','p','e','r','t','y','`',' ','W','H','E','R','E',' ',
2698        '`','P','r','o','p','e','r','t','y','`','=','\'','%','s','\'',0};
2699
2700     TRACE("(%d, %s, %p, %p)\n", hProduct, debugstr_w(szProperty),
2701           szValue, pccbValue);
2702
2703     if (!szProperty)
2704         return ERROR_INVALID_PARAMETER;
2705
2706     if (szValue && !pccbValue)
2707         return ERROR_INVALID_PARAMETER;
2708
2709     package = msihandle2msiinfo(hProduct, MSIHANDLETYPE_PACKAGE);
2710     if (!package)
2711         return ERROR_INVALID_HANDLE;
2712
2713     r = MSI_OpenQuery(package->db, &view, query, szProperty);
2714     if (r != ERROR_SUCCESS)
2715         goto done;
2716
2717     r = MSI_ViewExecute(view, 0);
2718     if (r != ERROR_SUCCESS)
2719         goto done;
2720
2721     r = MSI_ViewFetch(view, &rec);
2722     if (r != ERROR_SUCCESS)
2723         goto done;
2724
2725     val = MSI_RecordGetString(rec, 2);
2726     if (!val)
2727         goto done;
2728
2729     if (lstrlenW(val) >= *pccbValue)
2730     {
2731         lstrcpynW(szValue, val, *pccbValue);
2732         *pccbValue = lstrlenW(val);
2733         r = ERROR_MORE_DATA;
2734     }
2735     else
2736     {
2737         lstrcpyW(szValue, val);
2738         *pccbValue = lstrlenW(val);
2739         r = ERROR_SUCCESS;
2740     }
2741
2742 done:
2743     if (view)
2744     {
2745         MSI_ViewClose(view);
2746         msiobj_release(&view->hdr);
2747         if (rec) msiobj_release(&rec->hdr);
2748     }
2749
2750     if (!rec)
2751     {
2752         if (szValue) *szValue = '\0';
2753         if (pccbValue) *pccbValue = 0;
2754         r = ERROR_SUCCESS;
2755     }
2756
2757     msiobj_release(&package->hdr);
2758     return r;
2759 }
2760
2761 UINT WINAPI MsiVerifyPackageA( LPCSTR szPackage )
2762 {
2763     UINT r;
2764     LPWSTR szPack = NULL;
2765
2766     TRACE("%s\n", debugstr_a(szPackage) );
2767
2768     if( szPackage )
2769     {
2770         szPack = strdupAtoW( szPackage );
2771         if( !szPack )
2772             return ERROR_OUTOFMEMORY;
2773     }
2774
2775     r = MsiVerifyPackageW( szPack );
2776
2777     msi_free( szPack );
2778
2779     return r;
2780 }
2781
2782 UINT WINAPI MsiVerifyPackageW( LPCWSTR szPackage )
2783 {
2784     MSIHANDLE handle;
2785     UINT r;
2786
2787     TRACE("%s\n", debugstr_w(szPackage) );
2788
2789     r = MsiOpenDatabaseW( szPackage, MSIDBOPEN_READONLY, &handle );
2790     MsiCloseHandle( handle );
2791
2792     return r;
2793 }
2794
2795 static INSTALLSTATE MSI_GetComponentPath(LPCWSTR szProduct, LPCWSTR szComponent,
2796                                          awstring* lpPathBuf, LPDWORD pcchBuf)
2797 {
2798     static const WCHAR wininstaller[] =
2799         {'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
2800     WCHAR squished_pc[GUID_SIZE];
2801     WCHAR squished_comp[GUID_SIZE];
2802     HKEY hkey;
2803     LPWSTR path = NULL;
2804     INSTALLSTATE state;
2805     DWORD version;
2806
2807     if (!szProduct || !szComponent)
2808         return INSTALLSTATE_INVALIDARG;
2809
2810     if (lpPathBuf->str.w && !pcchBuf)
2811         return INSTALLSTATE_INVALIDARG;
2812
2813     if (!squash_guid(szProduct, squished_pc) ||
2814         !squash_guid(szComponent, squished_comp))
2815         return INSTALLSTATE_INVALIDARG;
2816
2817     state = INSTALLSTATE_UNKNOWN;
2818
2819     if (MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkey, FALSE) == ERROR_SUCCESS ||
2820         MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkey, FALSE) == ERROR_SUCCESS)
2821     {
2822         path = msi_reg_get_val_str(hkey, squished_pc);
2823         RegCloseKey(hkey);
2824
2825         state = INSTALLSTATE_ABSENT;
2826
2827         if ((MSIREG_OpenInstallProps(szProduct, MSIINSTALLCONTEXT_MACHINE, NULL,
2828                                      &hkey, FALSE) == ERROR_SUCCESS ||
2829             MSIREG_OpenUserDataProductKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
2830                                           NULL, &hkey, FALSE) == ERROR_SUCCESS) &&
2831             msi_reg_get_val_dword(hkey, wininstaller, &version) &&
2832             GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
2833         {
2834             RegCloseKey(hkey);
2835             state = INSTALLSTATE_LOCAL;
2836         }
2837     }
2838
2839     if (state != INSTALLSTATE_LOCAL &&
2840         (MSIREG_OpenProductKey(szProduct, NULL,
2841                                MSIINSTALLCONTEXT_USERUNMANAGED,
2842                                &hkey, FALSE) == ERROR_SUCCESS ||
2843          MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
2844                                &hkey, FALSE) == ERROR_SUCCESS))
2845     {
2846         RegCloseKey(hkey);
2847
2848         if (MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkey, FALSE) == ERROR_SUCCESS ||
2849             MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkey, FALSE) == ERROR_SUCCESS)
2850         {
2851             msi_free(path);
2852             path = msi_reg_get_val_str(hkey, squished_pc);
2853             RegCloseKey(hkey);
2854
2855             state = INSTALLSTATE_ABSENT;
2856
2857             if (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
2858                 state = INSTALLSTATE_LOCAL;
2859         }
2860     }
2861
2862     if (!path)
2863         return INSTALLSTATE_UNKNOWN;
2864
2865     if (state == INSTALLSTATE_LOCAL && !*path)
2866         state = INSTALLSTATE_NOTUSED;
2867
2868     msi_strcpy_to_awstring(path, -1, lpPathBuf, pcchBuf);
2869     msi_free(path);
2870     return state;
2871 }
2872
2873 /******************************************************************
2874  * MsiGetComponentPathW      [MSI.@]
2875  */
2876 INSTALLSTATE WINAPI MsiGetComponentPathW(LPCWSTR szProduct, LPCWSTR szComponent,
2877                                          LPWSTR lpPathBuf, LPDWORD pcchBuf)
2878 {
2879     awstring path;
2880
2881     TRACE("%s %s %p %p\n", debugstr_w(szProduct), debugstr_w(szComponent), lpPathBuf, pcchBuf);
2882
2883     path.unicode = TRUE;
2884     path.str.w = lpPathBuf;
2885
2886     return MSI_GetComponentPath( szProduct, szComponent, &path, pcchBuf );
2887 }
2888
2889 /******************************************************************
2890  * MsiGetComponentPathA      [MSI.@]
2891  */
2892 INSTALLSTATE WINAPI MsiGetComponentPathA(LPCSTR szProduct, LPCSTR szComponent,
2893                                          LPSTR lpPathBuf, LPDWORD pcchBuf)
2894 {
2895     LPWSTR szwProduct, szwComponent = NULL;
2896     INSTALLSTATE r = INSTALLSTATE_UNKNOWN;
2897     awstring path;
2898
2899     TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szComponent), lpPathBuf, pcchBuf);
2900
2901     szwProduct = strdupAtoW( szProduct );
2902     if( szProduct && !szwProduct)
2903         goto end;
2904
2905     szwComponent = strdupAtoW( szComponent );
2906     if( szComponent && !szwComponent )
2907         goto end;
2908
2909     path.unicode = FALSE;
2910     path.str.a = lpPathBuf;
2911
2912     r = MSI_GetComponentPath( szwProduct, szwComponent, &path, pcchBuf );
2913
2914 end:
2915     msi_free( szwProduct );
2916     msi_free( szwComponent );
2917
2918     return r;
2919 }
2920
2921 /******************************************************************
2922  * MsiQueryFeatureStateA      [MSI.@]
2923  */
2924 INSTALLSTATE WINAPI MsiQueryFeatureStateA(LPCSTR szProduct, LPCSTR szFeature)
2925 {
2926     LPWSTR szwProduct = NULL, szwFeature= NULL;
2927     INSTALLSTATE rc = INSTALLSTATE_UNKNOWN;
2928
2929     szwProduct = strdupAtoW( szProduct );
2930     if ( szProduct && !szwProduct )
2931         goto end;
2932
2933     szwFeature = strdupAtoW( szFeature );
2934     if ( szFeature && !szwFeature )
2935         goto end;
2936
2937     rc = MsiQueryFeatureStateW(szwProduct, szwFeature);
2938
2939 end:
2940     msi_free( szwProduct);
2941     msi_free( szwFeature);
2942
2943     return rc;
2944 }
2945
2946 /******************************************************************
2947  * MsiQueryFeatureStateW      [MSI.@]
2948  *
2949  * Checks the state of a feature
2950  *
2951  * PARAMS
2952  *   szProduct     [I]  Product's GUID string
2953  *   szFeature     [I]  Feature's GUID string
2954  *
2955  * RETURNS
2956  *   INSTALLSTATE_LOCAL        Feature is installed and usable
2957  *   INSTALLSTATE_ABSENT       Feature is absent
2958  *   INSTALLSTATE_ADVERTISED   Feature should be installed on demand
2959  *   INSTALLSTATE_UNKNOWN      An error occurred
2960  *   INSTALLSTATE_INVALIDARG   One of the GUIDs was invalid
2961  *
2962  */
2963 INSTALLSTATE WINAPI MsiQueryFeatureStateW(LPCWSTR szProduct, LPCWSTR szFeature)
2964 {
2965     WCHAR squishProduct[33], comp[GUID_SIZE];
2966     GUID guid;
2967     LPWSTR components, p, parent_feature, path;
2968     UINT rc;
2969     HKEY hkey;
2970     INSTALLSTATE r;
2971     BOOL missing = FALSE;
2972     BOOL machine = FALSE;
2973     BOOL source = FALSE;
2974
2975     TRACE("%s %s\n", debugstr_w(szProduct), debugstr_w(szFeature));
2976
2977     if (!szProduct || !szFeature)
2978         return INSTALLSTATE_INVALIDARG;
2979
2980     if (!squash_guid( szProduct, squishProduct ))
2981         return INSTALLSTATE_INVALIDARG;
2982
2983     SetLastError( ERROR_SUCCESS );
2984
2985     if (MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_USERMANAGED,
2986                                &hkey, FALSE) != ERROR_SUCCESS &&
2987         MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
2988                                &hkey, FALSE) != ERROR_SUCCESS)
2989     {
2990         rc = MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_MACHINE,
2991                                     &hkey, FALSE);
2992         if (rc != ERROR_SUCCESS)
2993             return INSTALLSTATE_UNKNOWN;
2994
2995         machine = TRUE;
2996     }
2997
2998     parent_feature = msi_reg_get_val_str( hkey, szFeature );
2999     RegCloseKey(hkey);
3000
3001     if (!parent_feature)
3002         return INSTALLSTATE_UNKNOWN;
3003
3004     r = (parent_feature[0] == 6) ? INSTALLSTATE_ABSENT : INSTALLSTATE_LOCAL;
3005     msi_free(parent_feature);
3006     if (r == INSTALLSTATE_ABSENT)
3007         return r;
3008
3009     if (machine)
3010         rc = MSIREG_OpenUserDataFeaturesKey(szProduct,
3011                                             MSIINSTALLCONTEXT_MACHINE,
3012                                             &hkey, FALSE);
3013     else
3014         rc = MSIREG_OpenUserDataFeaturesKey(szProduct,
3015                                             MSIINSTALLCONTEXT_USERUNMANAGED,
3016                                             &hkey, FALSE);
3017
3018     if (rc != ERROR_SUCCESS)
3019         return INSTALLSTATE_ADVERTISED;
3020
3021     components = msi_reg_get_val_str( hkey, szFeature );
3022     RegCloseKey(hkey);
3023
3024     TRACE("rc = %d buffer = %s\n", rc, debugstr_w(components));
3025
3026     if (!components)
3027         return INSTALLSTATE_ADVERTISED;
3028
3029     for( p = components; *p && *p != 2 ; p += 20)
3030     {
3031         if (!decode_base85_guid( p, &guid ))
3032         {
3033             if (p != components)
3034                 break;
3035
3036             msi_free(components);
3037             return INSTALLSTATE_BADCONFIG;
3038         }
3039
3040         StringFromGUID2(&guid, comp, GUID_SIZE);
3041
3042         if (machine)
3043             rc = MSIREG_OpenUserDataComponentKey(comp, szLocalSid, &hkey, FALSE);
3044         else
3045             rc = MSIREG_OpenUserDataComponentKey(comp, NULL, &hkey, FALSE);
3046
3047         if (rc != ERROR_SUCCESS)
3048         {
3049             msi_free(components);
3050             return INSTALLSTATE_ADVERTISED;
3051         }
3052
3053         path = msi_reg_get_val_str(hkey, squishProduct);
3054         if (!path)
3055             missing = TRUE;
3056         else if (lstrlenW(path) > 2 &&
3057                  path[0] >= '0' && path[0] <= '9' &&
3058                  path[1] >= '0' && path[1] <= '9')
3059         {
3060             source = TRUE;
3061         }
3062
3063         msi_free(path);
3064     }
3065     msi_free(components);
3066
3067     if (missing)
3068         r = INSTALLSTATE_ADVERTISED;
3069     else if (source)
3070         r = INSTALLSTATE_SOURCE;
3071     else
3072         r = INSTALLSTATE_LOCAL;
3073
3074     TRACE("-> %d\n", r);
3075     return r;
3076 }
3077
3078 /******************************************************************
3079  * MsiGetFileVersionA         [MSI.@]
3080  */
3081 UINT WINAPI MsiGetFileVersionA(LPCSTR szFilePath, LPSTR lpVersionBuf,
3082                 LPDWORD pcchVersionBuf, LPSTR lpLangBuf, LPDWORD pcchLangBuf)
3083 {
3084     LPWSTR szwFilePath = NULL, lpwVersionBuff = NULL, lpwLangBuff = NULL;
3085     UINT ret = ERROR_OUTOFMEMORY;
3086
3087     if ((lpVersionBuf && !pcchVersionBuf) ||
3088         (lpLangBuf && !pcchLangBuf))
3089         return ERROR_INVALID_PARAMETER;
3090
3091     if( szFilePath )
3092     {
3093         szwFilePath = strdupAtoW( szFilePath );
3094         if( !szwFilePath )
3095             goto end;
3096     }
3097
3098     if( lpVersionBuf && pcchVersionBuf && *pcchVersionBuf )
3099     {
3100         lpwVersionBuff = msi_alloc(*pcchVersionBuf*sizeof(WCHAR));
3101         if( !lpwVersionBuff )
3102             goto end;
3103     }
3104
3105     if( lpLangBuf && pcchLangBuf && *pcchLangBuf )
3106     {
3107         lpwLangBuff = msi_alloc(*pcchLangBuf*sizeof(WCHAR));
3108         if( !lpwLangBuff )
3109             goto end;
3110     }
3111
3112     ret = MsiGetFileVersionW(szwFilePath, lpwVersionBuff, pcchVersionBuf,
3113                              lpwLangBuff, pcchLangBuf);
3114
3115     if( (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && lpwVersionBuff )
3116         WideCharToMultiByte(CP_ACP, 0, lpwVersionBuff, -1,
3117                             lpVersionBuf, *pcchVersionBuf + 1, NULL, NULL);
3118     if( (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && lpwLangBuff )
3119         WideCharToMultiByte(CP_ACP, 0, lpwLangBuff, -1,
3120                             lpLangBuf, *pcchLangBuf + 1, NULL, NULL);
3121
3122 end:
3123     msi_free(szwFilePath);
3124     msi_free(lpwVersionBuff);
3125     msi_free(lpwLangBuff);
3126
3127     return ret;
3128 }
3129
3130 static UINT get_file_version( const WCHAR *path, WCHAR *verbuf, DWORD *verlen,
3131                               WCHAR *langbuf, DWORD *langlen )
3132 {
3133     static const WCHAR szVersionResource[] = {'\\',0};
3134     static const WCHAR szVersionFormat[] = {'%','d','.','%','d','.','%','d','.','%','d',0};
3135     static const WCHAR szLangFormat[] = {'%','d',0};
3136     UINT ret = ERROR_SUCCESS;
3137     DWORD len, error;
3138     LPVOID version;
3139     VS_FIXEDFILEINFO *ffi;
3140     USHORT *lang;
3141     WCHAR tmp[32];
3142
3143     if (!(len = GetFileVersionInfoSizeW( path, NULL )))
3144     {
3145         error = GetLastError();
3146         if (error == ERROR_BAD_PATHNAME) return ERROR_FILE_NOT_FOUND;
3147         return error;
3148     }
3149     if (!(version = msi_alloc( len ))) return ERROR_OUTOFMEMORY;
3150     if (!GetFileVersionInfoW( path, 0, len, version ))
3151     {
3152         msi_free( version );
3153         return GetLastError();
3154     }
3155     if (verlen)
3156     {
3157         if (VerQueryValueW( version, szVersionResource, (LPVOID *)&ffi, &len ) && len > 0)
3158         {
3159             sprintfW( tmp, szVersionFormat,
3160                       HIWORD(ffi->dwFileVersionMS), LOWORD(ffi->dwFileVersionMS),
3161                       HIWORD(ffi->dwFileVersionLS), LOWORD(ffi->dwFileVersionLS) );
3162             if (verbuf) lstrcpynW( verbuf, tmp, *verlen );
3163             len = strlenW( tmp );
3164             if (len >= *verlen) ret = ERROR_MORE_DATA;
3165             *verlen = len;
3166         }
3167         else
3168         {
3169             if (verbuf) *verbuf = 0;
3170             *verlen = 0;
3171         }
3172     }
3173     if (langlen)
3174     {
3175         if (VerQueryValueW( version, szLangResource, (LPVOID *)&lang, &len ) && len > 0)
3176         {
3177             sprintfW( tmp, szLangFormat, *lang );
3178             if (langbuf) lstrcpynW( langbuf, tmp, *langlen );
3179             len = strlenW( tmp );
3180             if (len >= *langlen) ret = ERROR_MORE_DATA;
3181             *langlen = len;
3182         }
3183         else
3184         {
3185             if (langbuf) *langbuf = 0;
3186             *langlen = 0;
3187         }
3188     }
3189     msi_free( version );
3190     return ret;
3191 }
3192
3193
3194 /******************************************************************
3195  * MsiGetFileVersionW         [MSI.@]
3196  */
3197 UINT WINAPI MsiGetFileVersionW( LPCWSTR path, LPWSTR verbuf, LPDWORD verlen,
3198                                 LPWSTR langbuf, LPDWORD langlen )
3199 {
3200     UINT ret;
3201
3202     TRACE("%s %p %u %p %u\n", debugstr_w(path), verbuf, verlen ? *verlen : 0,
3203           langbuf, langlen ? *langlen : 0);
3204
3205     if ((verbuf && !verlen) || (langbuf && !langlen))
3206         return ERROR_INVALID_PARAMETER;
3207
3208     ret = get_file_version( path, verbuf, verlen, langbuf, langlen );
3209     if (ret == ERROR_RESOURCE_DATA_NOT_FOUND && verlen)
3210     {
3211         int len;
3212         WCHAR *version = msi_font_version_from_file( path );
3213         if (!version) return ERROR_FILE_INVALID;
3214         len = strlenW( version );
3215         if (len >= *verlen) ret = ERROR_MORE_DATA;
3216         else if (verbuf)
3217         {
3218             strcpyW( verbuf, version );
3219             ret = ERROR_SUCCESS;
3220         }
3221         *verlen = len;
3222         msi_free( version );
3223     }
3224     return ret;
3225 }
3226
3227 /***********************************************************************
3228  * MsiGetFeatureUsageW           [MSI.@]
3229  */
3230 UINT WINAPI MsiGetFeatureUsageW( LPCWSTR szProduct, LPCWSTR szFeature,
3231                                  LPDWORD pdwUseCount, LPWORD pwDateUsed )
3232 {
3233     FIXME("%s %s %p %p\n",debugstr_w(szProduct), debugstr_w(szFeature),
3234           pdwUseCount, pwDateUsed);
3235     return ERROR_CALL_NOT_IMPLEMENTED;
3236 }
3237
3238 /***********************************************************************
3239  * MsiGetFeatureUsageA           [MSI.@]
3240  */
3241 UINT WINAPI MsiGetFeatureUsageA( LPCSTR szProduct, LPCSTR szFeature,
3242                                  LPDWORD pdwUseCount, LPWORD pwDateUsed )
3243 {
3244     LPWSTR prod = NULL, feat = NULL;
3245     UINT ret = ERROR_OUTOFMEMORY;
3246
3247     TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szFeature),
3248           pdwUseCount, pwDateUsed);
3249
3250     prod = strdupAtoW( szProduct );
3251     if (szProduct && !prod)
3252         goto end;
3253
3254     feat = strdupAtoW( szFeature );
3255     if (szFeature && !feat)
3256         goto end;
3257
3258     ret = MsiGetFeatureUsageW( prod, feat, pdwUseCount, pwDateUsed );
3259
3260 end:
3261     msi_free( prod );
3262     msi_free( feat );
3263
3264     return ret;
3265 }
3266
3267 /***********************************************************************
3268  * MsiUseFeatureExW           [MSI.@]
3269  */
3270 INSTALLSTATE WINAPI MsiUseFeatureExW( LPCWSTR szProduct, LPCWSTR szFeature,
3271                                       DWORD dwInstallMode, DWORD dwReserved )
3272 {
3273     INSTALLSTATE state;
3274
3275     TRACE("%s %s %i %i\n", debugstr_w(szProduct), debugstr_w(szFeature),
3276           dwInstallMode, dwReserved);
3277
3278     state = MsiQueryFeatureStateW( szProduct, szFeature );
3279
3280     if (dwReserved)
3281         return INSTALLSTATE_INVALIDARG;
3282
3283     if (state == INSTALLSTATE_LOCAL && dwInstallMode != INSTALLMODE_NODETECTION)
3284     {
3285         FIXME("mark product %s feature %s as used\n",
3286               debugstr_w(szProduct), debugstr_w(szFeature) );
3287     }
3288
3289     return state;
3290 }
3291
3292 /***********************************************************************
3293  * MsiUseFeatureExA           [MSI.@]
3294  */
3295 INSTALLSTATE WINAPI MsiUseFeatureExA( LPCSTR szProduct, LPCSTR szFeature,
3296                                       DWORD dwInstallMode, DWORD dwReserved )
3297 {
3298     INSTALLSTATE ret = INSTALLSTATE_UNKNOWN;
3299     LPWSTR prod = NULL, feat = NULL;
3300
3301     TRACE("%s %s %i %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
3302           dwInstallMode, dwReserved);
3303
3304     prod = strdupAtoW( szProduct );
3305     if (szProduct && !prod)
3306         goto end;
3307
3308     feat = strdupAtoW( szFeature );
3309     if (szFeature && !feat)
3310         goto end;
3311
3312     ret = MsiUseFeatureExW( prod, feat, dwInstallMode, dwReserved );
3313
3314 end:
3315     msi_free( prod );
3316     msi_free( feat );
3317
3318     return ret;
3319 }
3320
3321 /***********************************************************************
3322  * MsiUseFeatureW             [MSI.@]
3323  */
3324 INSTALLSTATE WINAPI MsiUseFeatureW( LPCWSTR szProduct, LPCWSTR szFeature )
3325 {
3326     return MsiUseFeatureExW(szProduct, szFeature, 0, 0);
3327 }
3328
3329 /***********************************************************************
3330  * MsiUseFeatureA             [MSI.@]
3331  */
3332 INSTALLSTATE WINAPI MsiUseFeatureA( LPCSTR szProduct, LPCSTR szFeature )
3333 {
3334     return MsiUseFeatureExA(szProduct, szFeature, 0, 0);
3335 }
3336
3337 /***********************************************************************
3338  * MSI_ProvideQualifiedComponentEx [internal]
3339  */
3340 static UINT MSI_ProvideQualifiedComponentEx(LPCWSTR szComponent,
3341                 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
3342                 DWORD Unused1, DWORD Unused2, awstring *lpPathBuf,
3343                 LPDWORD pcchPathBuf)
3344 {
3345     WCHAR product[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1],
3346           feature[MAX_FEATURE_CHARS+1];
3347     LPWSTR info;
3348     HKEY hkey;
3349     DWORD sz;
3350     UINT rc;
3351
3352     rc = MSIREG_OpenUserComponentsKey(szComponent, &hkey, FALSE);
3353     if (rc != ERROR_SUCCESS)
3354         return ERROR_INDEX_ABSENT;
3355
3356     info = msi_reg_get_val_str( hkey, szQualifier );
3357     RegCloseKey(hkey);
3358
3359     if (!info)
3360         return ERROR_INDEX_ABSENT;
3361
3362     MsiDecomposeDescriptorW(info, product, feature, component, &sz);
3363
3364     if (!szProduct)
3365         rc = MSI_GetComponentPath(product, component, lpPathBuf, pcchPathBuf);
3366     else
3367         rc = MSI_GetComponentPath(szProduct, component, lpPathBuf, pcchPathBuf);
3368
3369     msi_free( info );
3370
3371     if (rc != INSTALLSTATE_LOCAL)
3372         return ERROR_FILE_NOT_FOUND;
3373
3374     return ERROR_SUCCESS;
3375 }
3376
3377 /***********************************************************************
3378  * MsiProvideQualifiedComponentExW [MSI.@]
3379  */
3380 UINT WINAPI MsiProvideQualifiedComponentExW(LPCWSTR szComponent,
3381                 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
3382                 DWORD Unused1, DWORD Unused2, LPWSTR lpPathBuf,
3383                 LPDWORD pcchPathBuf)
3384 {
3385     awstring path;
3386
3387     TRACE("%s %s %u %s %u %u %p %p\n", debugstr_w(szComponent),
3388           debugstr_w(szQualifier), dwInstallMode, debugstr_w(szProduct),
3389           Unused1, Unused2, lpPathBuf, pcchPathBuf);
3390
3391     path.unicode = TRUE;
3392     path.str.w = lpPathBuf;
3393
3394     return MSI_ProvideQualifiedComponentEx(szComponent, szQualifier,
3395             dwInstallMode, szProduct, Unused1, Unused2, &path, pcchPathBuf);
3396 }
3397
3398 /***********************************************************************
3399  * MsiProvideQualifiedComponentExA [MSI.@]
3400  */
3401 UINT WINAPI MsiProvideQualifiedComponentExA(LPCSTR szComponent,
3402                 LPCSTR szQualifier, DWORD dwInstallMode, LPCSTR szProduct,
3403                 DWORD Unused1, DWORD Unused2, LPSTR lpPathBuf,
3404                 LPDWORD pcchPathBuf)
3405 {
3406     LPWSTR szwComponent, szwQualifier = NULL, szwProduct = NULL;
3407     UINT r = ERROR_OUTOFMEMORY;
3408     awstring path;
3409
3410     TRACE("%s %s %u %s %u %u %p %p\n", debugstr_a(szComponent),
3411           debugstr_a(szQualifier), dwInstallMode, debugstr_a(szProduct),
3412           Unused1, Unused2, lpPathBuf, pcchPathBuf);
3413
3414     szwComponent = strdupAtoW( szComponent );
3415     if (szComponent && !szwComponent)
3416         goto end;
3417
3418     szwQualifier = strdupAtoW( szQualifier );
3419     if (szQualifier && !szwQualifier)
3420         goto end;
3421
3422     szwProduct = strdupAtoW( szProduct );
3423     if (szProduct && !szwProduct)
3424         goto end;
3425
3426     path.unicode = FALSE;
3427     path.str.a = lpPathBuf;
3428
3429     r = MSI_ProvideQualifiedComponentEx(szwComponent, szwQualifier,
3430                               dwInstallMode, szwProduct, Unused1,
3431                               Unused2, &path, pcchPathBuf);
3432 end:
3433     msi_free(szwProduct);
3434     msi_free(szwComponent);
3435     msi_free(szwQualifier);
3436
3437     return r;
3438 }
3439
3440 /***********************************************************************
3441  * MsiProvideQualifiedComponentW [MSI.@]
3442  */
3443 UINT WINAPI MsiProvideQualifiedComponentW( LPCWSTR szComponent,
3444                 LPCWSTR szQualifier, DWORD dwInstallMode, LPWSTR lpPathBuf,
3445                 LPDWORD pcchPathBuf)
3446 {
3447     return MsiProvideQualifiedComponentExW(szComponent, szQualifier,
3448                     dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
3449 }
3450
3451 /***********************************************************************
3452  * MsiProvideQualifiedComponentA [MSI.@]
3453  */
3454 UINT WINAPI MsiProvideQualifiedComponentA( LPCSTR szComponent,
3455                 LPCSTR szQualifier, DWORD dwInstallMode, LPSTR lpPathBuf,
3456                 LPDWORD pcchPathBuf)
3457 {
3458     return MsiProvideQualifiedComponentExA(szComponent, szQualifier,
3459                               dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
3460 }
3461
3462 /***********************************************************************
3463  * MSI_GetUserInfo [internal]
3464  */
3465 static USERINFOSTATE MSI_GetUserInfo(LPCWSTR szProduct,
3466                 awstring *lpUserNameBuf, LPDWORD pcchUserNameBuf,
3467                 awstring *lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
3468                 awstring *lpSerialBuf, LPDWORD pcchSerialBuf)
3469 {
3470     WCHAR squished_pc[SQUISH_GUID_SIZE];
3471     LPWSTR user, org, serial;
3472     USERINFOSTATE state;
3473     HKEY hkey, props;
3474     LPCWSTR orgptr;
3475     UINT r;
3476
3477     TRACE("%s %p %p %p %p %p %p\n", debugstr_w(szProduct), lpUserNameBuf,
3478           pcchUserNameBuf, lpOrgNameBuf, pcchOrgNameBuf, lpSerialBuf,
3479           pcchSerialBuf);
3480
3481     if (!szProduct || !squash_guid(szProduct, squished_pc))
3482         return USERINFOSTATE_INVALIDARG;
3483
3484     if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
3485                               &hkey, FALSE) != ERROR_SUCCESS &&
3486         MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3487                               &hkey, FALSE) != ERROR_SUCCESS &&
3488         MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
3489                               &hkey, FALSE) != ERROR_SUCCESS)
3490     {
3491         return USERINFOSTATE_UNKNOWN;
3492     }
3493
3494     if (MSIREG_OpenInstallProps(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
3495                                 NULL, &props, FALSE) != ERROR_SUCCESS &&
3496         MSIREG_OpenInstallProps(szProduct, MSIINSTALLCONTEXT_MACHINE,
3497                                 NULL, &props, FALSE) != ERROR_SUCCESS)
3498     {
3499         RegCloseKey(hkey);
3500         return USERINFOSTATE_ABSENT;
3501     }
3502
3503     user = msi_reg_get_val_str(props, INSTALLPROPERTY_REGOWNERW);
3504     org = msi_reg_get_val_str(props, INSTALLPROPERTY_REGCOMPANYW);
3505     serial = msi_reg_get_val_str(props, INSTALLPROPERTY_PRODUCTIDW);
3506     state = USERINFOSTATE_ABSENT;
3507
3508     RegCloseKey(hkey);
3509     RegCloseKey(props);
3510
3511     if (user && serial)
3512         state = USERINFOSTATE_PRESENT;
3513
3514     if (pcchUserNameBuf)
3515     {
3516         if (lpUserNameBuf && !user)
3517         {
3518             (*pcchUserNameBuf)--;
3519             goto done;
3520         }
3521
3522         r = msi_strcpy_to_awstring(user, -1, lpUserNameBuf, pcchUserNameBuf);
3523         if (r == ERROR_MORE_DATA)
3524         {
3525             state = USERINFOSTATE_MOREDATA;
3526             goto done;
3527         }
3528     }
3529
3530     if (pcchOrgNameBuf)
3531     {
3532         orgptr = org;
3533         if (!orgptr) orgptr = szEmpty;
3534
3535         r = msi_strcpy_to_awstring(orgptr, -1, lpOrgNameBuf, pcchOrgNameBuf);
3536         if (r == ERROR_MORE_DATA)
3537         {
3538             state = USERINFOSTATE_MOREDATA;
3539             goto done;
3540         }
3541     }
3542
3543     if (pcchSerialBuf)
3544     {
3545         if (!serial)
3546         {
3547             (*pcchSerialBuf)--;
3548             goto done;
3549         }
3550
3551         r = msi_strcpy_to_awstring(serial, -1, lpSerialBuf, pcchSerialBuf);
3552         if (r == ERROR_MORE_DATA)
3553             state = USERINFOSTATE_MOREDATA;
3554     }
3555
3556 done:
3557     msi_free(user);
3558     msi_free(org);
3559     msi_free(serial);
3560
3561     return state;
3562 }
3563
3564 /***********************************************************************
3565  * MsiGetUserInfoW [MSI.@]
3566  */
3567 USERINFOSTATE WINAPI MsiGetUserInfoW(LPCWSTR szProduct,
3568                 LPWSTR lpUserNameBuf, LPDWORD pcchUserNameBuf,
3569                 LPWSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
3570                 LPWSTR lpSerialBuf, LPDWORD pcchSerialBuf)
3571 {
3572     awstring user, org, serial;
3573
3574     if ((lpUserNameBuf && !pcchUserNameBuf) ||
3575         (lpOrgNameBuf && !pcchOrgNameBuf) ||
3576         (lpSerialBuf && !pcchSerialBuf))
3577         return USERINFOSTATE_INVALIDARG;
3578
3579     user.unicode = TRUE;
3580     user.str.w = lpUserNameBuf;
3581     org.unicode = TRUE;
3582     org.str.w = lpOrgNameBuf;
3583     serial.unicode = TRUE;
3584     serial.str.w = lpSerialBuf;
3585
3586     return MSI_GetUserInfo( szProduct, &user, pcchUserNameBuf,
3587                             &org, pcchOrgNameBuf,
3588                             &serial, pcchSerialBuf );
3589 }
3590
3591 USERINFOSTATE WINAPI MsiGetUserInfoA(LPCSTR szProduct,
3592                 LPSTR lpUserNameBuf, LPDWORD pcchUserNameBuf,
3593                 LPSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
3594                 LPSTR lpSerialBuf, LPDWORD pcchSerialBuf)
3595 {
3596     awstring user, org, serial;
3597     LPWSTR prod;
3598     UINT r;
3599
3600     if ((lpUserNameBuf && !pcchUserNameBuf) ||
3601         (lpOrgNameBuf && !pcchOrgNameBuf) ||
3602         (lpSerialBuf && !pcchSerialBuf))
3603         return USERINFOSTATE_INVALIDARG;
3604
3605     prod = strdupAtoW( szProduct );
3606     if (szProduct && !prod)
3607         return ERROR_OUTOFMEMORY;
3608
3609     user.unicode = FALSE;
3610     user.str.a = lpUserNameBuf;
3611     org.unicode = FALSE;
3612     org.str.a = lpOrgNameBuf;
3613     serial.unicode = FALSE;
3614     serial.str.a = lpSerialBuf;
3615
3616     r = MSI_GetUserInfo( prod, &user, pcchUserNameBuf,
3617                          &org, pcchOrgNameBuf,
3618                          &serial, pcchSerialBuf );
3619
3620     msi_free( prod );
3621
3622     return r;
3623 }
3624
3625 UINT WINAPI MsiCollectUserInfoW(LPCWSTR szProduct)
3626 {
3627     MSIHANDLE handle;
3628     UINT rc;
3629     MSIPACKAGE *package;
3630     static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
3631
3632     TRACE("(%s)\n",debugstr_w(szProduct));
3633
3634     rc = MsiOpenProductW(szProduct,&handle);
3635     if (rc != ERROR_SUCCESS)
3636         return ERROR_INVALID_PARAMETER;
3637
3638     /* MsiCollectUserInfo cannot be called from a custom action. */
3639     package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
3640     if (!package)
3641         return ERROR_CALL_NOT_IMPLEMENTED;
3642
3643     rc = ACTION_PerformUIAction(package, szFirstRun, SCRIPT_NONE);
3644     msiobj_release( &package->hdr );
3645
3646     MsiCloseHandle(handle);
3647
3648     return rc;
3649 }
3650
3651 UINT WINAPI MsiCollectUserInfoA(LPCSTR szProduct)
3652 {
3653     MSIHANDLE handle;
3654     UINT rc;
3655     MSIPACKAGE *package;
3656     static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
3657
3658     TRACE("(%s)\n",debugstr_a(szProduct));
3659
3660     rc = MsiOpenProductA(szProduct,&handle);
3661     if (rc != ERROR_SUCCESS)
3662         return ERROR_INVALID_PARAMETER;
3663
3664     /* MsiCollectUserInfo cannot be called from a custom action. */
3665     package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
3666     if (!package)
3667         return ERROR_CALL_NOT_IMPLEMENTED;
3668
3669     rc = ACTION_PerformUIAction(package, szFirstRun, SCRIPT_NONE);
3670     msiobj_release( &package->hdr );
3671
3672     MsiCloseHandle(handle);
3673
3674     return rc;
3675 }
3676
3677 /***********************************************************************
3678  * MsiConfigureFeatureA            [MSI.@]
3679  */
3680 UINT WINAPI MsiConfigureFeatureA(LPCSTR szProduct, LPCSTR szFeature, INSTALLSTATE eInstallState)
3681 {
3682     LPWSTR prod, feat = NULL;
3683     UINT r = ERROR_OUTOFMEMORY;
3684
3685     TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature), eInstallState);
3686
3687     prod = strdupAtoW( szProduct );
3688     if (szProduct && !prod)
3689         goto end;
3690
3691     feat = strdupAtoW( szFeature );
3692     if (szFeature && !feat)
3693         goto end;
3694
3695     r = MsiConfigureFeatureW(prod, feat, eInstallState);
3696
3697 end:
3698     msi_free(feat);
3699     msi_free(prod);
3700
3701     return r;
3702 }
3703
3704 /***********************************************************************
3705  * MsiConfigureFeatureW            [MSI.@]
3706  */
3707 UINT WINAPI MsiConfigureFeatureW(LPCWSTR szProduct, LPCWSTR szFeature, INSTALLSTATE eInstallState)
3708 {
3709     MSIPACKAGE *package = NULL;
3710     UINT r;
3711     WCHAR sourcepath[MAX_PATH], filename[MAX_PATH];
3712     DWORD sz;
3713
3714     TRACE("%s %s %i\n", debugstr_w(szProduct), debugstr_w(szFeature), eInstallState);
3715
3716     if (!szProduct || !szFeature)
3717         return ERROR_INVALID_PARAMETER;
3718
3719     switch (eInstallState)
3720     {
3721     case INSTALLSTATE_DEFAULT:
3722         /* FIXME: how do we figure out the default location? */
3723         eInstallState = INSTALLSTATE_LOCAL;
3724         break;
3725     case INSTALLSTATE_LOCAL:
3726     case INSTALLSTATE_SOURCE:
3727     case INSTALLSTATE_ABSENT:
3728     case INSTALLSTATE_ADVERTISED:
3729         break;
3730     default:
3731         return ERROR_INVALID_PARAMETER;
3732     }
3733
3734     r = MSI_OpenProductW( szProduct, &package );
3735     if (r != ERROR_SUCCESS)
3736         return r;
3737
3738     sz = sizeof(sourcepath);
3739     MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3740                 MSICODE_PRODUCT, INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
3741
3742     sz = sizeof(filename);
3743     MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3744                 MSICODE_PRODUCT, INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
3745
3746     lstrcatW( sourcepath, filename );
3747
3748     MsiSetInternalUI( INSTALLUILEVEL_BASIC, NULL );
3749
3750     r = ACTION_PerformUIAction( package, szCostInitialize, SCRIPT_NONE );
3751     if (r != ERROR_SUCCESS)
3752         goto end;
3753
3754     r = MSI_SetFeatureStateW( package, szFeature, eInstallState);
3755     if (r != ERROR_SUCCESS)
3756         goto end;
3757
3758     r = MSI_InstallPackage( package, sourcepath, NULL );
3759
3760 end:
3761     msiobj_release( &package->hdr );
3762
3763     return r;
3764 }
3765
3766 /***********************************************************************
3767  * MsiCreateAndVerifyInstallerDirectory [MSI.@]
3768  *
3769  * Notes: undocumented
3770  */
3771 UINT WINAPI MsiCreateAndVerifyInstallerDirectory(DWORD dwReserved)
3772 {
3773     WCHAR path[MAX_PATH];
3774
3775     TRACE("%d\n", dwReserved);
3776
3777     if (dwReserved)
3778     {
3779         FIXME("dwReserved=%d\n", dwReserved);
3780         return ERROR_INVALID_PARAMETER;
3781     }
3782
3783     if (!GetWindowsDirectoryW(path, MAX_PATH))
3784         return ERROR_FUNCTION_FAILED;
3785
3786     lstrcatW(path, installerW);
3787
3788     if (!CreateDirectoryW(path, NULL))
3789         return ERROR_FUNCTION_FAILED;
3790
3791     return ERROR_SUCCESS;
3792 }
3793
3794 /***********************************************************************
3795  * MsiGetShortcutTargetA           [MSI.@]
3796  */
3797 UINT WINAPI MsiGetShortcutTargetA( LPCSTR szShortcutTarget,
3798                                    LPSTR szProductCode, LPSTR szFeatureId,
3799                                    LPSTR szComponentCode )
3800 {
3801     LPWSTR target;
3802     const int len = MAX_FEATURE_CHARS+1;
3803     WCHAR product[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1];
3804     UINT r;
3805
3806     target = strdupAtoW( szShortcutTarget );
3807     if (szShortcutTarget && !target )
3808         return ERROR_OUTOFMEMORY;
3809     product[0] = 0;
3810     feature[0] = 0;
3811     component[0] = 0;
3812     r = MsiGetShortcutTargetW( target, product, feature, component );
3813     msi_free( target );
3814     if (r == ERROR_SUCCESS)
3815     {
3816         WideCharToMultiByte( CP_ACP, 0, product, -1, szProductCode, len, NULL, NULL );
3817         WideCharToMultiByte( CP_ACP, 0, feature, -1, szFeatureId, len, NULL, NULL );
3818         WideCharToMultiByte( CP_ACP, 0, component, -1, szComponentCode, len, NULL, NULL );
3819     }
3820     return r;
3821 }
3822
3823 /***********************************************************************
3824  * MsiGetShortcutTargetW           [MSI.@]
3825  */
3826 UINT WINAPI MsiGetShortcutTargetW( LPCWSTR szShortcutTarget,
3827                                    LPWSTR szProductCode, LPWSTR szFeatureId,
3828                                    LPWSTR szComponentCode )
3829 {
3830     IShellLinkDataList *dl = NULL;
3831     IPersistFile *pf = NULL;
3832     LPEXP_DARWIN_LINK darwin = NULL;
3833     HRESULT r, init;
3834
3835     TRACE("%s %p %p %p\n", debugstr_w(szShortcutTarget),
3836           szProductCode, szFeatureId, szComponentCode );
3837
3838     init = CoInitialize(NULL);
3839
3840     r = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3841                           &IID_IPersistFile, (LPVOID*) &pf );
3842     if( SUCCEEDED( r ) )
3843     {
3844         r = IPersistFile_Load( pf, szShortcutTarget,
3845                                STGM_READ | STGM_SHARE_DENY_WRITE );
3846         if( SUCCEEDED( r ) )
3847         {
3848             r = IPersistFile_QueryInterface( pf, &IID_IShellLinkDataList,
3849                                              (LPVOID*) &dl );
3850             if( SUCCEEDED( r ) )
3851             {
3852                 IShellLinkDataList_CopyDataBlock( dl, EXP_DARWIN_ID_SIG,
3853                                                   (LPVOID) &darwin );
3854                 IShellLinkDataList_Release( dl );
3855             }
3856         }
3857         IPersistFile_Release( pf );
3858     }
3859
3860     if (SUCCEEDED(init))
3861         CoUninitialize();
3862
3863     TRACE("darwin = %p\n", darwin);
3864
3865     if (darwin)
3866     {
3867         DWORD sz;
3868         UINT ret;
3869
3870         ret = MsiDecomposeDescriptorW( darwin->szwDarwinID,
3871                   szProductCode, szFeatureId, szComponentCode, &sz );
3872         LocalFree( darwin );
3873         return ret;
3874     }
3875
3876     return ERROR_FUNCTION_FAILED;
3877 }
3878
3879 UINT WINAPI MsiReinstallFeatureW( LPCWSTR szProduct, LPCWSTR szFeature, DWORD dwReinstallMode )
3880 {
3881     static const WCHAR fmtW[] = {'%','s','=','%','s',' ','%','s','=','%','s',0};
3882     MSIPACKAGE *package;
3883     MSIINSTALLCONTEXT context;
3884     UINT r;
3885     WCHAR sourcepath[MAX_PATH], filename[MAX_PATH], reinstallmode[11];
3886     WCHAR *ptr, *cmdline;
3887     DWORD sz;
3888
3889     TRACE("%s, %s, 0x%08x\n", debugstr_w(szProduct), debugstr_w(szFeature), dwReinstallMode);
3890
3891     r = msi_locate_product( szProduct, &context );
3892     if (r != ERROR_SUCCESS)
3893         return r;
3894
3895     ptr = reinstallmode;
3896
3897     if (dwReinstallMode & REINSTALLMODE_FILEMISSING)
3898         *ptr++ = 'p';
3899     if (dwReinstallMode & REINSTALLMODE_FILEOLDERVERSION)
3900         *ptr++ = 'o';
3901     if (dwReinstallMode & REINSTALLMODE_FILEEQUALVERSION)
3902         *ptr++ = 'w';
3903     if (dwReinstallMode & REINSTALLMODE_FILEEXACT)
3904         *ptr++ = 'd';
3905     if (dwReinstallMode & REINSTALLMODE_FILEVERIFY)
3906         *ptr++ = 'c';
3907     if (dwReinstallMode & REINSTALLMODE_FILEREPLACE)
3908         *ptr++ = 'a';
3909     if (dwReinstallMode & REINSTALLMODE_USERDATA)
3910         *ptr++ = 'u';
3911     if (dwReinstallMode & REINSTALLMODE_MACHINEDATA)
3912         *ptr++ = 'm';
3913     if (dwReinstallMode & REINSTALLMODE_SHORTCUT)
3914         *ptr++ = 's';
3915     if (dwReinstallMode & REINSTALLMODE_PACKAGE)
3916         *ptr++ = 'v';
3917     *ptr = 0;
3918
3919     sz = sizeof(sourcepath);
3920     MsiSourceListGetInfoW( szProduct, NULL, context, MSICODE_PRODUCT,
3921                            INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz );
3922     sz = sizeof(filename);
3923     MsiSourceListGetInfoW( szProduct, NULL, context, MSICODE_PRODUCT,
3924                            INSTALLPROPERTY_PACKAGENAMEW, filename, &sz );
3925     strcatW( sourcepath, filename );
3926
3927     if (dwReinstallMode & REINSTALLMODE_PACKAGE)
3928         r = MSI_OpenPackageW( sourcepath, &package );
3929     else
3930         r = MSI_OpenProductW( szProduct, &package );
3931
3932     if (r != ERROR_SUCCESS)
3933         return r;
3934
3935     sz = (strlenW( fmtW ) + strlenW( szReinstallMode ) + strlenW( reinstallmode )) * sizeof(WCHAR);
3936     sz += (strlenW( szReinstall ) + strlenW( szFeature )) * sizeof(WCHAR);
3937     if (!(cmdline = msi_alloc( sz )))
3938     {
3939         msiobj_release( &package->hdr );
3940         return ERROR_OUTOFMEMORY;
3941     }
3942     sprintfW( cmdline, fmtW, szReinstallMode, reinstallmode, szReinstall, szFeature );
3943
3944     r = MSI_InstallPackage( package, sourcepath, cmdline );
3945     msiobj_release( &package->hdr );
3946     msi_free( cmdline );
3947
3948     return r;
3949 }
3950
3951 UINT WINAPI MsiReinstallFeatureA( LPCSTR szProduct, LPCSTR szFeature,
3952                                   DWORD dwReinstallMode )
3953 {
3954     LPWSTR wszProduct;
3955     LPWSTR wszFeature;
3956     UINT rc;
3957
3958     TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
3959                            dwReinstallMode);
3960
3961     wszProduct = strdupAtoW(szProduct);
3962     wszFeature = strdupAtoW(szFeature);
3963
3964     rc = MsiReinstallFeatureW(wszProduct, wszFeature, dwReinstallMode);
3965
3966     msi_free(wszProduct);
3967     msi_free(wszFeature);
3968     return rc;
3969 }
3970
3971 typedef struct
3972 {
3973     unsigned int i[2];
3974     unsigned int buf[4];
3975     unsigned char in[64];
3976     unsigned char digest[16];
3977 } MD5_CTX;
3978
3979 extern VOID WINAPI MD5Init( MD5_CTX *);
3980 extern VOID WINAPI MD5Update( MD5_CTX *, const unsigned char *, unsigned int );
3981 extern VOID WINAPI MD5Final( MD5_CTX *);
3982
3983 /***********************************************************************
3984  * MsiGetFileHashW            [MSI.@]
3985  */
3986 UINT WINAPI MsiGetFileHashW( LPCWSTR szFilePath, DWORD dwOptions,
3987                              PMSIFILEHASHINFO pHash )
3988 {
3989     HANDLE handle, mapping;
3990     void *p;
3991     DWORD length;
3992     UINT r = ERROR_FUNCTION_FAILED;
3993
3994     TRACE("%s %08x %p\n", debugstr_w(szFilePath), dwOptions, pHash );
3995
3996     if (!szFilePath)
3997         return ERROR_INVALID_PARAMETER;
3998
3999     if (!*szFilePath)
4000         return ERROR_PATH_NOT_FOUND;
4001
4002     if (dwOptions)
4003         return ERROR_INVALID_PARAMETER;
4004     if (!pHash)
4005         return ERROR_INVALID_PARAMETER;
4006     if (pHash->dwFileHashInfoSize < sizeof *pHash)
4007         return ERROR_INVALID_PARAMETER;
4008
4009     handle = CreateFileW( szFilePath, GENERIC_READ,
4010                           FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, NULL );
4011     if (handle == INVALID_HANDLE_VALUE)
4012     {
4013         WARN("can't open file %u\n", GetLastError());
4014         return ERROR_FILE_NOT_FOUND;
4015     }
4016     length = GetFileSize( handle, NULL );
4017
4018     if (length)
4019     {
4020         mapping = CreateFileMappingW( handle, NULL, PAGE_READONLY, 0, 0, NULL );
4021         if (mapping)
4022         {
4023             p = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, length );
4024             if (p)
4025             {
4026                 MD5_CTX ctx;
4027
4028                 MD5Init( &ctx );
4029                 MD5Update( &ctx, p, length );
4030                 MD5Final( &ctx );
4031                 UnmapViewOfFile( p );
4032
4033                 memcpy( pHash->dwData, ctx.digest, sizeof pHash->dwData );
4034                 r = ERROR_SUCCESS;
4035             }
4036             CloseHandle( mapping );
4037         }
4038     }
4039     else
4040     {
4041         /* Empty file -> set hash to 0 */
4042         memset( pHash->dwData, 0, sizeof pHash->dwData );
4043         r = ERROR_SUCCESS;
4044     }
4045
4046     CloseHandle( handle );
4047
4048     return r;
4049 }
4050
4051 /***********************************************************************
4052  * MsiGetFileHashA            [MSI.@]
4053  */
4054 UINT WINAPI MsiGetFileHashA( LPCSTR szFilePath, DWORD dwOptions,
4055                              PMSIFILEHASHINFO pHash )
4056 {
4057     LPWSTR file;
4058     UINT r;
4059
4060     TRACE("%s %08x %p\n", debugstr_a(szFilePath), dwOptions, pHash );
4061
4062     file = strdupAtoW( szFilePath );
4063     if (szFilePath && !file)
4064         return ERROR_OUTOFMEMORY;
4065
4066     r = MsiGetFileHashW( file, dwOptions, pHash );
4067     msi_free( file );
4068     return r;
4069 }
4070
4071 /***********************************************************************
4072  * MsiAdvertiseScriptW        [MSI.@]
4073  */
4074 UINT WINAPI MsiAdvertiseScriptW( LPCWSTR szScriptFile, DWORD dwFlags,
4075                                  PHKEY phRegData, BOOL fRemoveItems )
4076 {
4077     FIXME("%s %08x %p %d\n",
4078           debugstr_w( szScriptFile ), dwFlags, phRegData, fRemoveItems );
4079     return ERROR_CALL_NOT_IMPLEMENTED;
4080 }
4081
4082 /***********************************************************************
4083  * MsiAdvertiseScriptA        [MSI.@]
4084  */
4085 UINT WINAPI MsiAdvertiseScriptA( LPCSTR szScriptFile, DWORD dwFlags,
4086                                  PHKEY phRegData, BOOL fRemoveItems )
4087 {
4088     FIXME("%s %08x %p %d\n",
4089           debugstr_a( szScriptFile ), dwFlags, phRegData, fRemoveItems );
4090     return ERROR_CALL_NOT_IMPLEMENTED;
4091 }
4092
4093 /***********************************************************************
4094  * MsiIsProductElevatedW        [MSI.@]
4095  */
4096 UINT WINAPI MsiIsProductElevatedW( LPCWSTR szProduct, BOOL *pfElevated )
4097 {
4098     FIXME("%s %p - stub\n",
4099           debugstr_w( szProduct ), pfElevated );
4100     *pfElevated = TRUE;
4101     return ERROR_SUCCESS;
4102 }
4103
4104 /***********************************************************************
4105  * MsiIsProductElevatedA        [MSI.@]
4106  */
4107 UINT WINAPI MsiIsProductElevatedA( LPCSTR szProduct, BOOL *pfElevated )
4108 {
4109     FIXME("%s %p - stub\n",
4110           debugstr_a( szProduct ), pfElevated );
4111     *pfElevated = TRUE;
4112     return ERROR_SUCCESS;
4113 }
4114
4115 /***********************************************************************
4116  * MsiSetExternalUIRecord     [MSI.@]
4117  */
4118 UINT WINAPI MsiSetExternalUIRecord( INSTALLUI_HANDLER_RECORD handler,
4119                                     DWORD filter, LPVOID context,
4120                                     PINSTALLUI_HANDLER_RECORD prev )
4121 {
4122     TRACE("%p %08x %p %p\n", handler, filter, context, prev);
4123
4124     if (prev)
4125         *prev = gUIHandlerRecord;
4126
4127     gUIHandlerRecord = handler;
4128     gUIFilter        = filter;
4129     gUIContext       = context;
4130
4131     return ERROR_SUCCESS;
4132 }
4133
4134 /***********************************************************************
4135  * MsiInstallMissingComponentA     [MSI.@]
4136  */
4137 UINT WINAPI MsiInstallMissingComponentA( LPCSTR product, LPCSTR component, INSTALLSTATE state )
4138 {
4139     UINT r;
4140     WCHAR *productW = NULL, *componentW = NULL;
4141
4142     TRACE("%s, %s, %d\n", debugstr_a(product), debugstr_a(component), state);
4143
4144     if (product && !(productW = strdupAtoW( product )))
4145         return ERROR_OUTOFMEMORY;
4146
4147     if (component && !(componentW = strdupAtoW( component )))
4148     {
4149         msi_free( productW );
4150         return ERROR_OUTOFMEMORY;
4151     }
4152
4153     r = MsiInstallMissingComponentW( productW, componentW, state );
4154     msi_free( productW );
4155     msi_free( componentW );
4156     return r;
4157 }
4158
4159 /***********************************************************************
4160  * MsiInstallMissingComponentW     [MSI.@]
4161  */
4162 UINT WINAPI MsiInstallMissingComponentW(LPCWSTR szProduct, LPCWSTR szComponent, INSTALLSTATE eInstallState)
4163 {
4164     FIXME("(%s %s %d\n", debugstr_w(szProduct), debugstr_w(szComponent), eInstallState);
4165     return ERROR_SUCCESS;
4166 }
4167
4168 /***********************************************************************
4169  * MsiBeginTransactionA     [MSI.@]
4170  */
4171 UINT WINAPI MsiBeginTransactionA( LPCSTR name, DWORD attrs, MSIHANDLE *id, HANDLE *event )
4172 {
4173     WCHAR *nameW;
4174     UINT r;
4175
4176     FIXME("%s %u %p %p\n", debugstr_a(name), attrs, id, event);
4177
4178     nameW = strdupAtoW( name );
4179     if (name && !nameW)
4180         return ERROR_OUTOFMEMORY;
4181
4182     r = MsiBeginTransactionW( nameW, attrs, id, event );
4183     msi_free( nameW );
4184     return r;
4185 }
4186
4187 /***********************************************************************
4188  * MsiBeginTransactionW     [MSI.@]
4189  */
4190 UINT WINAPI MsiBeginTransactionW( LPCWSTR name, DWORD attrs, MSIHANDLE *id, HANDLE *event )
4191 {
4192     FIXME("%s %u %p %p\n", debugstr_w(name), attrs, id, event);
4193
4194     *id = (MSIHANDLE)0xdeadbeef;
4195     *event = (HANDLE)0xdeadbeef;
4196
4197     return ERROR_SUCCESS;
4198 }
4199
4200 /***********************************************************************
4201  * MsiEndTransaction     [MSI.@]
4202  */
4203 UINT WINAPI MsiEndTransaction( DWORD state )
4204 {
4205     FIXME("%u\n", state);
4206     return ERROR_SUCCESS;
4207 }
4208
4209 UINT WINAPI Migrate10CachedPackagesW(void* a, void* b, void* c, DWORD d)
4210 {
4211     FIXME("%p,%p,%p,%08x\n", a, b, c, d);
4212     return ERROR_SUCCESS;
4213 }