dlls/msi/package.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2004 Aric Stewart 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 #define NONAMELESSUNION
  22 #define NONAMELESSSTRUCT
  23 #define COBJMACROS
  24
  25 #include <stdarg.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winreg.h"
  29 #include "winnls.h"
  30 #include "winternl.h"
  31 #include "shlwapi.h"
  32 #include "wingdi.h"
  33 #include "msi.h"
  34 #include "msiquery.h"
  35 #include "objidl.h"
  36 #include "wincrypt.h"
  37 #include "winuser.h"
  38 #include "wininet.h"
  39 #include "winver.h"
  40 #include "urlmon.h"
  41 #include "shlobj.h"
  42 #include "objbase.h"
  43 #include "msidefs.h"
  44 #include "sddl.h"
  45
  46 #include "wine/debug.h"
  47 #include "wine/exception.h"
  48
  49 #include "msipriv.h"
  50 #include "winemsi.h"
  51 #include "resource.h"
  52
  53 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  54
  55 static void free_feature( MSIFEATURE *feature )
  56 {
  57     struct list *item, *cursor;
  58
  59     LIST_FOR_EACH_SAFE( item, cursor, &feature->Children )
  60     {
  61         FeatureList *fl = LIST_ENTRY( item, FeatureList, entry );
  62         list_remove( &fl->entry );
  63         free( fl );
  64     }
  65
  66     LIST_FOR_EACH_SAFE( item, cursor, &feature->Components )
  67     {
  68         ComponentList *cl = LIST_ENTRY( item, ComponentList, entry );
  69         list_remove( &cl->entry );
  70         free( cl );
  71     }
  72     free( feature->Feature );
  73     free( feature->Feature_Parent );
  74     free( feature->Directory );
  75     free( feature->Description );
  76     free( feature->Title );
  77     free( feature );
  78 }
  79
  80 static void free_folder( MSIFOLDER *folder )
  81 {
  82     struct list *item, *cursor;
  83
  84     LIST_FOR_EACH_SAFE( item, cursor, &folder->children )
  85     {
  86         FolderList *fl = LIST_ENTRY( item, FolderList, entry );
  87         list_remove( &fl->entry );
  88         free( fl );
  89     }
  90     free( folder->Parent );
  91     free( folder->Directory );
  92     free( folder->TargetDefault );
  93     free( folder->SourceLongPath );
  94     free( folder->SourceShortPath );
  95     free( folder->ResolvedTarget );
  96     free( folder->ResolvedSource );
  97     free( folder );
  98 }
  99
 100 static void free_extension( MSIEXTENSION *ext )
 101 {
 102     struct list *item, *cursor;
 103
 104     LIST_FOR_EACH_SAFE( item, cursor, &ext->verbs )
 105     {
 106         MSIVERB *verb = LIST_ENTRY( item, MSIVERB, entry );
 107
 108         list_remove( &verb->entry );
 109         free( verb->Verb );
 110         free( verb->Command );
 111         free( verb->Argument );
 112         free( verb );
 113     }
 114
 115     free( ext->Extension );
 116     free( ext->ProgIDText );
 117     free( ext );
 118 }
 119
 120 static void free_assembly( MSIASSEMBLY *assembly )
 121 {
 122     free( assembly->feature );
 123     free( assembly->manifest );
 124     free( assembly->application );
 125     free( assembly->display_name );
 126     if (assembly->tempdir) RemoveDirectoryW( assembly->tempdir );
 127     free( assembly->tempdir );
 128     free( assembly );
 129 }
 130
 131 void msi_free_action_script( MSIPACKAGE *package, UINT script )
 132 {
 133     UINT i;
 134     for (i = 0; i < package->script_actions_count[script]; i++)
 135         free( package->script_actions[script][i] );
 136
 137     free( package->script_actions[script] );
 138     package->script_actions[script] = NULL;
 139     package->script_actions_count[script] = 0;
 140 }
 141
 142 static void free_package_structures( MSIPACKAGE *package )
 143 {
 144     struct list *item, *cursor;
 145     int i;
 146
 147     LIST_FOR_EACH_SAFE( item, cursor, &package->features )
 148     {
 149         MSIFEATURE *feature = LIST_ENTRY( item, MSIFEATURE, entry );
 150         list_remove( &feature->entry );
 151         free_feature( feature );
 152     }
 153
 154     LIST_FOR_EACH_SAFE( item, cursor, &package->folders )
 155     {
 156         MSIFOLDER *folder = LIST_ENTRY( item, MSIFOLDER, entry );
 157         list_remove( &folder->entry );
 158         free_folder( folder );
 159     }
 160
 161     LIST_FOR_EACH_SAFE( item, cursor, &package->files )
 162     {
 163         MSIFILE *file = LIST_ENTRY( item, MSIFILE, entry );
 164
 165         list_remove( &file->entry );
 166         free( file->File );
 167         free( file->FileName );
 168         free( file->ShortName );
 169         free( file->LongName );
 170         free( file->Version );
 171         free( file->Language );
 172         if (msi_is_global_assembly( file->Component )) DeleteFileW( file->TargetPath );
 173         free( file->TargetPath );
 174         free( file );
 175     }
 176
 177     LIST_FOR_EACH_SAFE( item, cursor, &package->components )
 178     {
 179         MSICOMPONENT *comp = LIST_ENTRY( item, MSICOMPONENT, entry );
 180
 181         list_remove( &comp->entry );
 182         free( comp->Component );
 183         free( comp->ComponentId );
 184         free( comp->Directory );
 185         free( comp->Condition );
 186         free( comp->KeyPath );
 187         free( comp->FullKeypath );
 188         if (comp->assembly) free_assembly( comp->assembly );
 189         free( comp );
 190     }
 191
 192     LIST_FOR_EACH_SAFE( item, cursor, &package->filepatches )
 193     {
 194         MSIFILEPATCH *patch = LIST_ENTRY( item, MSIFILEPATCH, entry );
 195
 196         list_remove( &patch->entry );
 197         free( patch->path );
 198         free( patch );
 199     }
 200
 201     /* clean up extension, progid, class and verb structures */
 202     LIST_FOR_EACH_SAFE( item, cursor, &package->classes )
 203     {
 204         MSICLASS *cls = LIST_ENTRY( item, MSICLASS, entry );
 205
 206         list_remove( &cls->entry );
 207         free( cls->clsid );
 208         free( cls->Context );
 209         free( cls->Description );
 210         free( cls->FileTypeMask );
 211         free( cls->IconPath );
 212         free( cls->DefInprocHandler );
 213         free( cls->DefInprocHandler32 );
 214         free( cls->Argument );
 215         free( cls->ProgIDText );
 216         free( cls );
 217     }
 218
 219     LIST_FOR_EACH_SAFE( item, cursor, &package->extensions )
 220     {
 221         MSIEXTENSION *ext = LIST_ENTRY( item, MSIEXTENSION, entry );
 222
 223         list_remove( &ext->entry );
 224         free_extension( ext );
 225     }
 226
 227     LIST_FOR_EACH_SAFE( item, cursor, &package->progids )
 228     {
 229         MSIPROGID *progid = LIST_ENTRY( item, MSIPROGID, entry );
 230
 231         list_remove( &progid->entry );
 232         free( progid->ProgID );
 233         free( progid->Description );
 234         free( progid->IconPath );
 235         free( progid );
 236     }
 237
 238     LIST_FOR_EACH_SAFE( item, cursor, &package->mimes )
 239     {
 240         MSIMIME *mt = LIST_ENTRY( item, MSIMIME, entry );
 241
 242         list_remove( &mt->entry );
 243         free( mt->suffix );
 244         free( mt->clsid );
 245         free( mt->ContentType );
 246         free( mt );
 247     }
 248
 249     LIST_FOR_EACH_SAFE( item, cursor, &package->appids )
 250     {
 251         MSIAPPID *appid = LIST_ENTRY( item, MSIAPPID, entry );
 252
 253         list_remove( &appid->entry );
 254         free( appid->AppID );
 255         free( appid->RemoteServerName );
 256         free( appid->LocalServer );
 257         free( appid->ServiceParameters );
 258         free( appid->DllSurrogate );
 259         free( appid );
 260     }
 261
 262     LIST_FOR_EACH_SAFE( item, cursor, &package->sourcelist_info )
 263     {
 264         MSISOURCELISTINFO *info = LIST_ENTRY( item, MSISOURCELISTINFO, entry );
 265
 266         list_remove( &info->entry );
 267         free( info->value );
 268         free( info );
 269     }
 270
 271     LIST_FOR_EACH_SAFE( item, cursor, &package->sourcelist_media )
 272     {
 273         MSIMEDIADISK *info = LIST_ENTRY( item, MSIMEDIADISK, entry );
 274
 275         list_remove( &info->entry );
 276         free( info->volume_label );
 277         free( info->disk_prompt );
 278         free( info );
 279     }
 280
 281     for (i = 0; i < SCRIPT_MAX; i++)
 282         msi_free_action_script( package, i );
 283
 284     for (i = 0; i < package->unique_actions_count; i++)
 285         free( package->unique_actions[i] );
 286     free( package->unique_actions );
 287
 288     LIST_FOR_EACH_SAFE( item, cursor, &package->binaries )
 289     {
 290         MSIBINARY *binary = LIST_ENTRY( item, MSIBINARY, entry );
 291
 292         list_remove( &binary->entry );
 293         if (!DeleteFileW( binary->tmpfile ))
 294             ERR( "failed to delete %s (%lu)\n", debugstr_w(binary->tmpfile), GetLastError() );
 295         free( binary->source );
 296         free( binary->tmpfile );
 297         free( binary );
 298     }
 299
 300     LIST_FOR_EACH_SAFE( item, cursor, &package->cabinet_streams )
 301     {
 302         MSICABINETSTREAM *cab = LIST_ENTRY( item, MSICABINETSTREAM, entry );
 303
 304         list_remove( &cab->entry );
 305         IStorage_Release( cab->storage );
 306         free( cab->stream );
 307         free( cab );
 308     }
 309
 310     LIST_FOR_EACH_SAFE( item, cursor, &package->patches )
 311     {
 312         MSIPATCHINFO *patch = LIST_ENTRY( item, MSIPATCHINFO, entry );
 313
 314         list_remove( &patch->entry );
 315         if (patch->delete_on_close && !DeleteFileW( patch->localfile ))
 316         {
 317             ERR( "failed to delete %s (%lu)\n", debugstr_w(patch->localfile), GetLastError() );
 318         }
 319         msi_free_patchinfo( patch );
 320     }
 321
 322     free( package->PackagePath );
 323     free( package->ProductCode );
 324     free( package->ActionFormat );
 325     free( package->LastAction );
 326     free( package->LastActionTemplate );
 327     free( package->langids );
 328
 329     /* cleanup control event subscriptions */
 330     msi_event_cleanup_all_subscriptions( package );
 331 }
 332
 333 static void MSI_FreePackage( MSIOBJECTHDR *arg)
 334 {
 335     MSIPACKAGE *package = (MSIPACKAGE *)arg;
 336
 337     msi_destroy_assembly_caches( package );
 338
 339     if( package->dialog )
 340         msi_dialog_destroy( package->dialog );
 341
 342     msiobj_release( &package->db->hdr );
 343     free_package_structures(package);
 344     CloseHandle( package->log_file );
 345     if (package->rpc_server_started)
 346         RpcServerUnregisterIf(s_IWineMsiRemote_v0_0_s_ifspec, NULL, FALSE);
 347     if (rpc_handle)
 348         RpcBindingFree(&rpc_handle);
 349     if (package->custom_server_32_process)
 350         custom_stop_server(package->custom_server_32_process, package->custom_server_32_pipe);
 351     if (package->custom_server_64_process)
 352         custom_stop_server(package->custom_server_64_process, package->custom_server_64_pipe);
 353
 354     if (package->delete_on_close) DeleteFileW( package->localfile );
 355     free( package->localfile );
 356     MSI_ProcessMessage(NULL, INSTALLMESSAGE_TERMINATE, 0);
 357 }
 358
 359 static UINT create_temp_property_table(MSIPACKAGE *package)
 360 {
 361     MSIQUERY *view;
 362     UINT rc;
 363
 364     rc = MSI_DatabaseOpenViewW(package->db, L"CREATE TABLE `_Property` ( `_Property` CHAR(56) NOT NULL TEMPORARY, "
 365                                             L"`Value` CHAR(98) NOT NULL TEMPORARY PRIMARY KEY `_Property`) HOLD", &view);
 366     if (rc != ERROR_SUCCESS)
 367         return rc;
 368
 369     rc = MSI_ViewExecute(view, 0);
 370     MSI_ViewClose(view);
 371     msiobj_release(&view->hdr);
 372     return rc;
 373 }
 374
 375 UINT msi_clone_properties( MSIDATABASE *db )
 376 {
 377     MSIQUERY *view_select;
 378     UINT rc;
 379
 380     rc = MSI_DatabaseOpenViewW( db, L"SELECT * FROM `Property`", &view_select );
 381     if (rc != ERROR_SUCCESS)
 382         return rc;
 383
 384     rc = MSI_ViewExecute( view_select, 0 );
 385     if (rc != ERROR_SUCCESS)
 386     {
 387         MSI_ViewClose( view_select );
 388         msiobj_release( &view_select->hdr );
 389         return rc;
 390     }
 391
 392     while (1)
 393     {
 394         MSIQUERY *view_insert, *view_update;
 395         MSIRECORD *rec_select;
 396
 397         rc = MSI_ViewFetch( view_select, &rec_select );
 398         if (rc != ERROR_SUCCESS)
 399             break;
 400
 401         rc = MSI_DatabaseOpenViewW( db, L"INSERT INTO `_Property` (`_Property`,`Value`) VALUES (?,?)", &view_insert );
 402         if (rc != ERROR_SUCCESS)
 403         {
 404             msiobj_release( &rec_select->hdr );
 405             continue;
 406         }
 407
 408         rc = MSI_ViewExecute( view_insert, rec_select );
 409         MSI_ViewClose( view_insert );
 410         msiobj_release( &view_insert->hdr );
 411         if (rc != ERROR_SUCCESS)
 412         {
 413             MSIRECORD *rec_update;
 414
 415             TRACE("insert failed, trying update\n");
 416
 417             rc = MSI_DatabaseOpenViewW( db, L"UPDATE `_Property` SET `Value` = ? WHERE `_Property` = ?", &view_update );
 418             if (rc != ERROR_SUCCESS)
 419             {
 420                 WARN("open view failed %u\n", rc);
 421                 msiobj_release( &rec_select->hdr );
 422                 continue;
 423             }
 424
 425             rec_update = MSI_CreateRecord( 2 );
 426             MSI_RecordCopyField( rec_select, 1, rec_update, 2 );
 427             MSI_RecordCopyField( rec_select, 2, rec_update, 1 );
 428             rc = MSI_ViewExecute( view_update, rec_update );
 429             if (rc != ERROR_SUCCESS)
 430                 WARN("update failed %u\n", rc);
 431
 432             MSI_ViewClose( view_update );
 433             msiobj_release( &view_update->hdr );
 434             msiobj_release( &rec_update->hdr );
 435         }
 436
 437         msiobj_release( &rec_select->hdr );
 438     }
 439
 440     MSI_ViewClose( view_select );
 441     msiobj_release( &view_select->hdr );
 442     return rc;
 443 }
 444
 445 /*
 446  * set_installed_prop
 447  *
 448  * Sets the "Installed" property to indicate that
 449  *  the product is installed for the current user.
 450  */
 451 static UINT set_installed_prop( MSIPACKAGE *package )
 452 {
 453     HKEY hkey;
 454     UINT r;
 455
 456     if (!package->ProductCode) return ERROR_FUNCTION_FAILED;
 457
 458     r = MSIREG_OpenUninstallKey( package->ProductCode, package->platform, &hkey, FALSE );
 459     if (r == ERROR_SUCCESS)
 460     {
 461         RegCloseKey( hkey );
 462         msi_set_property( package->db, L"Installed", L"1", -1 );
 463     }
 464     return r;
 465 }
 466
 467 static UINT set_user_sid_prop( MSIPACKAGE *package )
 468 {
 469     SID_NAME_USE use;
 470     LPWSTR user_name;
 471     LPWSTR sid_str = NULL, dom = NULL;
 472     DWORD size, dom_size;
 473     PSID psid = NULL;
 474     UINT r = ERROR_FUNCTION_FAILED;
 475
 476     size = 0;
 477     GetUserNameW( NULL, &size );
 478
 479     user_name = malloc( (size + 1) * sizeof(WCHAR) );
 480     if (!user_name)
 481         return ERROR_OUTOFMEMORY;
 482
 483     if (!GetUserNameW( user_name, &size ))
 484         goto done;
 485
 486     size = 0;
 487     dom_size = 0;
 488     LookupAccountNameW( NULL, user_name, NULL, &size, NULL, &dom_size, &use );
 489
 490     psid = malloc( size );
 491     dom = malloc( dom_size * sizeof (WCHAR) );
 492     if (!psid || !dom)
 493     {
 494         r = ERROR_OUTOFMEMORY;
 495         goto done;
 496     }
 497
 498     if (!LookupAccountNameW( NULL, user_name, psid, &size, dom, &dom_size, &use ))
 499         goto done;
 500
 501     if (!ConvertSidToStringSidW( psid, &sid_str ))
 502         goto done;
 503
 504     r = msi_set_property( package->db, L"UserSID", sid_str, -1 );
 505
 506 done:
 507     LocalFree( sid_str );
 508     free( dom );
 509     free( psid );
 510     free( user_name );
 511
 512     return r;
 513 }
 514
 515 static LPWSTR get_fusion_filename(MSIPACKAGE *package)
 516 {
 517     HKEY netsetup, hkey;
 518     LONG res;
 519     DWORD size, len, type;
 520     WCHAR windir[MAX_PATH], path[MAX_PATH], *filename = NULL;
 521
 522     res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\NET Framework Setup\\NDP", 0, KEY_CREATE_SUB_KEY,
 523                         &netsetup);
 524     if (res != ERROR_SUCCESS)
 525         return NULL;
 526
 527     if (!RegCreateKeyExW(netsetup, L"v4\\Client", 0, NULL, 0, KEY_QUERY_VALUE, NULL, &hkey, NULL))
 528     {
 529         size = sizeof(path);
 530         if (!RegQueryValueExW(hkey, L"InstallPath", NULL, &type, (BYTE *)path, &size))
 531         {
 532             len = lstrlenW(path) + lstrlenW(L"fusion.dll") + 2;
 533             if (!(filename = malloc(len * sizeof(WCHAR)))) return NULL;
 534
 535             lstrcpyW(filename, path);
 536             lstrcatW(filename, L"\\");
 537             lstrcatW(filename, L"fusion.dll");
 538             if (GetFileAttributesW(filename) != INVALID_FILE_ATTRIBUTES)
 539             {
 540                 TRACE( "found %s\n", debugstr_w(filename) );
 541                 RegCloseKey(hkey);
 542                 RegCloseKey(netsetup);
 543                 return filename;
 544             }
 545         }
 546         RegCloseKey(hkey);
 547     }
 548
 549     if (!RegCreateKeyExW(netsetup, L"v2.0.50727", 0, NULL, 0, KEY_QUERY_VALUE, NULL, &hkey, NULL))
 550     {
 551         RegCloseKey(hkey);
 552         GetWindowsDirectoryW(windir, MAX_PATH);
 553         len = lstrlenW(windir) + lstrlenW(L"Microsoft.NET\\Framework\\") + lstrlenW(L"v2.0.50727") +
 554               lstrlenW(L"fusion.dll") + 3;
 555         free(filename);
 556         if (!(filename = malloc(len * sizeof(WCHAR)))) return NULL;
 557
 558         lstrcpyW(filename, windir);
 559         lstrcatW(filename, L"\\");
 560         lstrcatW(filename, L"Microsoft.NET\\Framework\\");
 561         lstrcatW(filename, L"v2.0.50727");
 562         lstrcatW(filename, L"\\");
 563         lstrcatW(filename, L"fusion.dll");
 564         if (GetFileAttributesW(filename) != INVALID_FILE_ATTRIBUTES)
 565         {
 566             TRACE( "found %s\n", debugstr_w(filename) );
 567             RegCloseKey(netsetup);
 568             return filename;
 569         }
 570     }
 571
 572     RegCloseKey(netsetup);
 573     return filename;
 574 }
 575
 576 struct lang_codepage
 577 {
 578   WORD wLanguage;
 579   WORD wCodePage;
 580 };
 581
 582 static void set_msi_assembly_prop(MSIPACKAGE *package)
 583 {
 584     UINT val_len;
 585     DWORD size, handle;
 586     LPVOID version = NULL;
 587     WCHAR buf[MAX_PATH];
 588     LPWSTR fusion, verstr;
 589     struct lang_codepage *translate;
 590
 591     fusion = get_fusion_filename(package);
 592     if (!fusion)
 593         return;
 594
 595     size = GetFileVersionInfoSizeW(fusion, &handle);
 596     if (!size)
 597         goto done;
 598
 599     version = malloc(size);
 600     if (!version)
 601         goto done;
 602
 603     if (!GetFileVersionInfoW(fusion, handle, size, version))
 604         goto done;
 605
 606     if (!VerQueryValueW(version, L"\\VarFileInfo\\Translation", (LPVOID *)&translate, &val_len))
 607         goto done;
 608
 609     swprintf(buf, ARRAY_SIZE(buf), L"\\StringFileInfo\\%04x%04x\\ProductVersion", translate[0].wLanguage,
 610              translate[0].wCodePage);
 611
 612     if (!VerQueryValueW(version, buf, (LPVOID *)&verstr, &val_len))
 613         goto done;
 614
 615     if (!val_len || !verstr)
 616         goto done;
 617
 618     msi_set_property( package->db, L"MsiNetAssemblySupport", verstr, -1 );
 619
 620 done:
 621     free(fusion);
 622     free(version);
 623 }
 624
 625 static VOID set_installer_properties(MSIPACKAGE *package)
 626 {
 627     WCHAR *ptr;
 628     RTL_OSVERSIONINFOEXW OSVersion;
 629     MEMORYSTATUSEX msex;
 630     DWORD verval, len, type;
 631     WCHAR pth[MAX_PATH], verstr[11], bufstr[22];
 632     HDC dc;
 633     HKEY hkey;
 634     LPWSTR username, companyname;
 635     SYSTEM_INFO sys_info;
 636     LANGID langid;
 637
 638     /*
 639      * Other things that probably should be set:
 640      *
 641      * VirtualMemory ShellAdvSupport DefaultUIFont PackagecodeChanging
 642      * CaptionHeight BorderTop BorderSide TextHeight RedirectedDllSupport
 643      */
 644
 645     SHGetFolderPathW(NULL, CSIDL_COMMON_APPDATA, NULL, 0, pth);
 646     lstrcatW(pth, L"\\");
 647     msi_set_property( package->db, L"CommonAppDataFolder", pth, -1 );
 648
 649     SHGetFolderPathW(NULL, CSIDL_FAVORITES, NULL, 0, pth);
 650     lstrcatW(pth, L"\\");
 651     msi_set_property( package->db, L"FavoritesFolder", pth, -1 );
 652
 653     SHGetFolderPathW(NULL, CSIDL_FONTS, NULL, 0, pth);
 654     lstrcatW(pth, L"\\");
 655     msi_set_property( package->db, L"FontsFolder", pth, -1 );
 656
 657     SHGetFolderPathW(NULL, CSIDL_SENDTO, NULL, 0, pth);
 658     lstrcatW(pth, L"\\");
 659     msi_set_property( package->db, L"SendToFolder", pth, -1 );
 660
 661     SHGetFolderPathW(NULL, CSIDL_STARTMENU, NULL, 0, pth);
 662     lstrcatW(pth, L"\\");
 663     msi_set_property( package->db, L"StartMenuFolder", pth, -1 );
 664
 665     SHGetFolderPathW(NULL, CSIDL_STARTUP, NULL, 0, pth);
 666     lstrcatW(pth, L"\\");
 667     msi_set_property( package->db, L"StartupFolder", pth, -1 );
 668
 669     SHGetFolderPathW(NULL, CSIDL_TEMPLATES, NULL, 0, pth);
 670     lstrcatW(pth, L"\\");
 671     msi_set_property( package->db, L"TemplateFolder", pth, -1 );
 672
 673     SHGetFolderPathW(NULL, CSIDL_DESKTOP, NULL, 0, pth);
 674     lstrcatW(pth, L"\\");
 675     msi_set_property( package->db, L"DesktopFolder", pth, -1 );
 676
 677     /* FIXME: set to AllUsers profile path if ALLUSERS is set */
 678     SHGetFolderPathW(NULL, CSIDL_PROGRAMS, NULL, 0, pth);
 679     lstrcatW(pth, L"\\");
 680     msi_set_property( package->db, L"ProgramMenuFolder", pth, -1 );
 681
 682     SHGetFolderPathW(NULL, CSIDL_ADMINTOOLS, NULL, 0, pth);
 683     lstrcatW(pth, L"\\");
 684     msi_set_property( package->db, L"AdminToolsFolder", pth, -1 );
 685
 686     SHGetFolderPathW(NULL, CSIDL_APPDATA, NULL, 0, pth);
 687     lstrcatW(pth, L"\\");
 688     msi_set_property( package->db, L"AppDataFolder", pth, -1 );
 689
 690     SHGetFolderPathW(NULL, CSIDL_SYSTEM, NULL, 0, pth);
 691     lstrcatW(pth, L"\\");
 692     msi_set_property( package->db, L"SystemFolder", pth, -1 );
 693     msi_set_property( package->db, L"System16Folder", pth, -1 );
 694
 695     SHGetFolderPathW(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, pth);
 696     lstrcatW(pth, L"\\");
 697     msi_set_property( package->db, L"LocalAppDataFolder", pth, -1 );
 698
 699     SHGetFolderPathW(NULL, CSIDL_MYPICTURES, NULL, 0, pth);
 700     lstrcatW(pth, L"\\");
 701     msi_set_property( package->db, L"MyPicturesFolder", pth, -1 );
 702
 703     SHGetFolderPathW(NULL, CSIDL_PERSONAL, NULL, 0, pth);
 704     lstrcatW(pth, L"\\");
 705     msi_set_property( package->db, L"PersonalFolder", pth, -1 );
 706
 707     SHGetFolderPathW(NULL, CSIDL_WINDOWS, NULL, 0, pth);
 708     lstrcatW(pth, L"\\");
 709     msi_set_property( package->db, L"WindowsFolder", pth, -1 );
 710
 711     SHGetFolderPathW(NULL, CSIDL_PRINTHOOD, NULL, 0, pth);
 712     lstrcatW(pth, L"\\");
 713     msi_set_property( package->db, L"PrintHoodFolder", pth, -1 );
 714
 715     SHGetFolderPathW(NULL, CSIDL_NETHOOD, NULL, 0, pth);
 716     lstrcatW(pth, L"\\");
 717     msi_set_property( package->db, L"NetHoodFolder", pth, -1 );
 718
 719     SHGetFolderPathW(NULL, CSIDL_RECENT, NULL, 0, pth);
 720     lstrcatW(pth, L"\\");
 721     msi_set_property( package->db, L"RecentFolder", pth, -1 );
 722
 723     /* Physical Memory is specified in MB. Using total amount. */
 724     msex.dwLength = sizeof(msex);
 725     GlobalMemoryStatusEx( &msex );
 726     len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%d", (int)(msex.ullTotalPhys / 1024 / 1024) );
 727     msi_set_property( package->db, L"PhysicalMemory", bufstr, len );
 728
 729     SHGetFolderPathW(NULL, CSIDL_WINDOWS, NULL, 0, pth);
 730     ptr = wcschr(pth,'\\');
 731     if (ptr) *(ptr + 1) = 0;
 732     msi_set_property( package->db, L"WindowsVolume", pth, -1 );
 733
 734     len = GetTempPathW(MAX_PATH, pth);
 735     msi_set_property( package->db, L"TempFolder", pth, len );
 736
 737     /* in a wine environment the user is always admin and privileged */
 738     msi_set_property( package->db, L"AdminUser", L"1", -1 );
 739     msi_set_property( package->db, L"Privileged", L"1", -1 );
 740     msi_set_property( package->db, L"MsiRunningElevated", L"1", -1 );
 741
 742     /* set the os things */
 743     OSVersion.dwOSVersionInfoSize = sizeof(OSVersion);
 744     RtlGetVersion(&OSVersion);
 745     verval = OSVersion.dwMinorVersion + OSVersion.dwMajorVersion * 100;
 746     if (verval > 603)
 747     {
 748         verval = 603;
 749         OSVersion.dwBuildNumber = 9600;
 750     }
 751     len = swprintf( verstr, ARRAY_SIZE(verstr), L"%u", verval );
 752     switch (OSVersion.dwPlatformId)
 753     {
 754         case VER_PLATFORM_WIN32_WINDOWS:
 755             msi_set_property( package->db, L"Version9X", verstr, len );
 756             break;
 757         case VER_PLATFORM_WIN32_NT:
 758             msi_set_property( package->db, L"VersionNT", verstr, len );
 759             len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%u", OSVersion.wProductType );
 760             msi_set_property( package->db, L"MsiNTProductType", bufstr, len );
 761             break;
 762     }
 763     len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%u", OSVersion.dwBuildNumber );
 764     msi_set_property( package->db, L"WindowsBuild", bufstr, len );
 765     len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%u", OSVersion.wServicePackMajor );
 766     msi_set_property( package->db, L"ServicePackLevel", bufstr, len );
 767
 768     len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%u.%u", MSI_MAJORVERSION, MSI_MINORVERSION );
 769     msi_set_property( package->db, L"VersionMsi", bufstr, len );
 770     len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%u", MSI_MAJORVERSION * 100 );
 771     msi_set_property( package->db, L"VersionDatabase", bufstr, len );
 772
 773     RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion", 0,
 774         KEY_QUERY_VALUE | KEY_WOW64_64KEY, &hkey);
 775
 776     GetNativeSystemInfo( &sys_info );
 777     len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%d", sys_info.wProcessorLevel );
 778     msi_set_property( package->db, L"Intel", bufstr, len );
 779     if (sys_info.u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL)
 780     {
 781         GetSystemDirectoryW( pth, MAX_PATH );
 782         PathAddBackslashW( pth );
 783         msi_set_property( package->db, L"SystemFolder", pth, -1 );
 784
 785         len = sizeof(pth);
 786         RegQueryValueExW(hkey, L"ProgramFilesDir", 0, &type, (BYTE *)pth, &len);
 787         PathAddBackslashW( pth );
 788         msi_set_property( package->db, L"ProgramFilesFolder", pth, -1 );
 789
 790         len = sizeof(pth);
 791         RegQueryValueExW(hkey, L"CommonFilesDir", 0, &type, (BYTE *)pth, &len);
 792         PathAddBackslashW( pth );
 793         msi_set_property( package->db, L"CommonFilesFolder", pth, -1 );
 794     }
 795     else if (sys_info.u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
 796     {
 797         msi_set_property( package->db, L"MsiAMD64", bufstr, -1 );
 798         msi_set_property( package->db, L"Msix64", bufstr, -1 );
 799         msi_set_property( package->db, L"VersionNT64", verstr, -1 );
 800
 801         GetSystemDirectoryW( pth, MAX_PATH );
 802         PathAddBackslashW( pth );
 803         msi_set_property( package->db, L"System64Folder", pth, -1 );
 804
 805         GetSystemWow64DirectoryW( pth, MAX_PATH );
 806         PathAddBackslashW( pth );
 807         msi_set_property( package->db, L"SystemFolder", pth, -1 );
 808
 809         len = sizeof(pth);
 810         RegQueryValueExW(hkey, L"ProgramFilesDir", 0, &type, (BYTE *)pth, &len);
 811         PathAddBackslashW( pth );
 812         msi_set_property( package->db, L"ProgramFiles64Folder", pth, -1 );
 813
 814         len = sizeof(pth);
 815         RegQueryValueExW(hkey, L"ProgramFilesDir (x86)", 0, &type, (BYTE *)pth, &len);
 816         PathAddBackslashW( pth );
 817         msi_set_property( package->db, L"ProgramFilesFolder", pth, -1 );
 818
 819         len = sizeof(pth);
 820         RegQueryValueExW(hkey, L"CommonFilesDir", 0, &type, (BYTE *)pth, &len);
 821         PathAddBackslashW( pth );
 822         msi_set_property( package->db, L"CommonFiles64Folder", pth, -1 );
 823
 824         len = sizeof(pth);
 825         RegQueryValueExW(hkey, L"CommonFilesDir (x86)", 0, &type, (BYTE *)pth, &len);
 826         PathAddBackslashW( pth );
 827         msi_set_property( package->db, L"CommonFilesFolder", pth, -1 );
 828     }
 829
 830     RegCloseKey(hkey);
 831
 832     /* Screen properties. */
 833     dc = GetDC(0);
 834     len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%d", GetDeviceCaps(dc, HORZRES) );
 835     msi_set_property( package->db, L"ScreenX", bufstr, len );
 836     len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%d", GetDeviceCaps(dc, VERTRES) );
 837     msi_set_property( package->db, L"ScreenY", bufstr, len );
 838     len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%d", GetDeviceCaps(dc, BITSPIXEL) );
 839     msi_set_property( package->db, L"ColorBits", bufstr, len );
 840     ReleaseDC(0, dc);
 841
 842     /* USERNAME and COMPANYNAME */
 843     username = msi_dup_property( package->db, L"USERNAME" );
 844     companyname = msi_dup_property( package->db, L"COMPANYNAME" );
 845
 846     if ((!username || !companyname) &&
 847         RegOpenKeyW( HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\MS Setup (ACME)\\User Info", &hkey ) == ERROR_SUCCESS)
 848     {
 849         if (!username &&
 850             (username = msi_reg_get_val_str( hkey, L"DefName" )))
 851             msi_set_property( package->db, L"USERNAME", username, -1 );
 852         if (!companyname &&
 853             (companyname = msi_reg_get_val_str( hkey, L"DefCompany" )))
 854             msi_set_property( package->db, L"COMPANYNAME", companyname, -1 );
 855         CloseHandle( hkey );
 856     }
 857     if ((!username || !companyname) &&
 858         RegOpenKeyExW( HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", 0,
 859                        KEY_QUERY_VALUE|KEY_WOW64_64KEY, &hkey ) == ERROR_SUCCESS)
 860     {
 861         if (!username &&
 862             (username = msi_reg_get_val_str( hkey, L"RegisteredOwner" )))
 863             msi_set_property( package->db, L"USERNAME", username, -1 );
 864         if (!companyname &&
 865             (companyname = msi_reg_get_val_str( hkey, L"RegisteredOrganization" )))
 866             msi_set_property( package->db, L"COMPANYNAME", companyname, -1 );
 867         CloseHandle( hkey );
 868     }
 869     free( username );
 870     free( companyname );
 871
 872     if ( set_user_sid_prop( package ) != ERROR_SUCCESS)
 873         ERR("Failed to set the UserSID property\n");
 874
 875     set_msi_assembly_prop( package );
 876
 877     langid = GetUserDefaultLangID();
 878     len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%d", langid );
 879     msi_set_property( package->db, L"UserLanguageID", bufstr, len );
 880
 881     langid = GetSystemDefaultLangID();
 882     len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%d", langid );
 883     msi_set_property( package->db, L"SystemLanguageID", bufstr, len );
 884
 885     len = swprintf( bufstr, ARRAY_SIZE(bufstr), L"%d", MsiQueryProductStateW(package->ProductCode) );
 886     msi_set_property( package->db, L"ProductState", bufstr, len );
 887
 888     len = 0;
 889     if (!GetUserNameW( NULL, &len ) && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 890     {
 891         WCHAR *username;
 892         if ((username = malloc( len * sizeof(WCHAR) )))
 893         {
 894             if (GetUserNameW( username, &len ))
 895                 msi_set_property( package->db, L"LogonUser", username, len - 1 );
 896             free( username );
 897         }
 898     }
 899     len = 0;
 900     if (!GetComputerNameW( NULL, &len ) && GetLastError() == ERROR_BUFFER_OVERFLOW)
 901     {
 902         WCHAR *computername;
 903         if ((computername = malloc( len * sizeof(WCHAR) )))
 904         {
 905             if (GetComputerNameW( computername, &len ))
 906                 msi_set_property( package->db, L"ComputerName", computername, len );
 907             free( computername );
 908         }
 909     }
 910 }
 911
 912 static MSIPACKAGE *alloc_package( void )
 913 {
 914     MSIPACKAGE *package;
 915
 916     package = alloc_msiobject( MSIHANDLETYPE_PACKAGE, sizeof (MSIPACKAGE),
 917                                MSI_FreePackage );
 918     if( package )
 919     {
 920         list_init( &package->components );
 921         list_init( &package->features );
 922         list_init( &package->files );
 923         list_init( &package->filepatches );
 924         list_init( &package->tempfiles );
 925         list_init( &package->folders );
 926         list_init( &package->subscriptions );
 927         list_init( &package->appids );
 928         list_init( &package->classes );
 929         list_init( &package->mimes );
 930         list_init( &package->extensions );
 931         list_init( &package->progids );
 932         list_init( &package->RunningActions );
 933         list_init( &package->sourcelist_info );
 934         list_init( &package->sourcelist_media );
 935         list_init( &package->patches );
 936         list_init( &package->binaries );
 937         list_init( &package->cabinet_streams );
 938     }
 939
 940     return package;
 941 }
 942
 943 static UINT load_admin_properties(MSIPACKAGE *package)
 944 {
 945     BYTE *data;
 946     UINT r, sz;
 947
 948     r = read_stream_data(package->db->storage, L"AdminProperties", FALSE, &data, &sz);
 949     if (r != ERROR_SUCCESS)
 950         return r;
 951
 952     r = msi_parse_command_line(package, (WCHAR *)data, TRUE);
 953
 954     free(data);
 955     return r;
 956 }
 957
 958 void msi_adjust_privilege_properties( MSIPACKAGE *package )
 959 {
 960     /* FIXME: this should depend on the user's privileges */
 961     if (msi_get_property_int( package->db, L"ALLUSERS", 0 ) == 2)
 962     {
 963         TRACE("resetting ALLUSERS property from 2 to 1\n");
 964         msi_set_property( package->db, L"ALLUSERS", L"1", -1 );
 965     }
 966     msi_set_property( package->db, L"AdminUser", L"1", -1 );
 967     msi_set_property( package->db, L"Privileged", L"1", -1 );
 968     msi_set_property( package->db, L"MsiRunningElevated", L"1", -1 );
 969 }
 970
 971 MSIPACKAGE *MSI_CreatePackage( MSIDATABASE *db )
 972 {
 973     MSIPACKAGE *package;
 974     WCHAR uilevel[11];
 975     int len;
 976     UINT r;
 977
 978     TRACE("%p\n", db);
 979
 980     package = alloc_package();
 981     if (package)
 982     {
 983         msiobj_addref( &db->hdr );
 984         package->db = db;
 985
 986         package->LastAction = NULL;
 987         package->LastActionTemplate = NULL;
 988         package->LastActionResult = MSI_NULL_INTEGER;
 989         package->WordCount = 0;
 990         package->PackagePath = wcsdup( db->path );
 991
 992         create_temp_property_table( package );
 993         msi_clone_properties( package->db );
 994         msi_adjust_privilege_properties( package );
 995
 996         package->ProductCode = msi_dup_property( package->db, L"ProductCode" );
 997
 998         set_installer_properties( package );
 999
1000         package->ui_level = gUILevel;
1001         len = swprintf( uilevel, ARRAY_SIZE(uilevel), L"%u", gUILevel & INSTALLUILEVEL_MASK );
1002         msi_set_property( package->db, L"UILevel", uilevel, len );
1003
1004         r = msi_load_suminfo_properties( package );
1005         if (r != ERROR_SUCCESS)
1006         {
1007             msiobj_release( &package->hdr );
1008             return NULL;
1009         }
1010
1011         if (package->WordCount & msidbSumInfoSourceTypeAdminImage)
1012             load_admin_properties( package );
1013
1014         package->log_file = INVALID_HANDLE_VALUE;
1015         package->script = SCRIPT_NONE;
1016     }
1017     return package;
1018 }
1019
1020 UINT msi_download_file( LPCWSTR szUrl, LPWSTR filename )
1021 {
1022     LPINTERNET_CACHE_ENTRY_INFOW cache_entry;
1023     DWORD size = 0;
1024     HRESULT hr;
1025
1026     /* call will always fail, because size is 0,
1027      * but will return ERROR_FILE_NOT_FOUND first
1028      * if the file doesn't exist
1029      */
1030     GetUrlCacheEntryInfoW( szUrl, NULL, &size );
1031     if ( GetLastError() != ERROR_FILE_NOT_FOUND )
1032     {
1033         cache_entry = malloc( size );
1034         if ( !GetUrlCacheEntryInfoW( szUrl, cache_entry, &size ) )
1035         {
1036             UINT error = GetLastError();
1037             free( cache_entry );
1038             return error;
1039         }
1040
1041         lstrcpyW( filename, cache_entry->lpszLocalFileName );
1042         free( cache_entry );
1043         return ERROR_SUCCESS;
1044     }
1045
1046     hr = URLDownloadToCacheFileW( NULL, szUrl, filename, MAX_PATH, 0, NULL );
1047     if ( FAILED(hr) )
1048     {
1049         WARN("failed to download %s to cache file\n", debugstr_w(szUrl));
1050         return ERROR_FUNCTION_FAILED;
1051     }
1052
1053     return ERROR_SUCCESS;
1054 }
1055
1056 UINT msi_create_empty_local_file( LPWSTR path, LPCWSTR suffix )
1057 {
1058     DWORD time, len, i, offset;
1059     HANDLE handle;
1060
1061     time = GetTickCount();
1062     GetWindowsDirectoryW( path, MAX_PATH );
1063     lstrcatW( path, L"\\Installer\\" );
1064     CreateDirectoryW( path, NULL );
1065
1066     len = lstrlenW(path);
1067     for (i = 0; i < 0x10000; i++)
1068     {
1069         offset = swprintf( path + len, MAX_PATH - len, L"%x", (time + i) & 0xffff );
1070         memcpy( path + len + offset, suffix, (lstrlenW( suffix ) + 1) * sizeof(WCHAR) );
1071         handle = CreateFileW( path, GENERIC_WRITE, 0, NULL,
1072                               CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
1073         if (handle != INVALID_HANDLE_VALUE)
1074         {
1075             CloseHandle(handle);
1076             break;
1077         }
1078         if (GetLastError() != ERROR_FILE_EXISTS &&
1079             GetLastError() != ERROR_SHARING_VIOLATION)
1080             return ERROR_FUNCTION_FAILED;
1081     }
1082
1083     return ERROR_SUCCESS;
1084 }
1085
1086 static enum platform parse_platform( const WCHAR *str )
1087 {
1088     if (!str[0] || !wcscmp( str, L"Intel" )) return PLATFORM_INTEL;
1089     else if (!wcscmp( str, L"Intel64" )) return PLATFORM_INTEL64;
1090     else if (!wcscmp( str, L"x64" ) || !wcscmp( str, L"AMD64" )) return PLATFORM_X64;
1091     else if (!wcscmp( str, L"Arm" )) return PLATFORM_ARM;
1092     else if (!wcscmp( str, L"Arm64" )) return PLATFORM_ARM64;
1093     return PLATFORM_UNRECOGNIZED;
1094 }
1095
1096 static UINT parse_suminfo( MSISUMMARYINFO *si, MSIPACKAGE *package )
1097 {
1098     WCHAR *template, *p, *q, *platform;
1099     DWORD i, count;
1100
1101     package->version = msi_suminfo_get_int32( si, PID_PAGECOUNT );
1102     TRACE("version: %d\n", package->version);
1103
1104     template = msi_suminfo_dup_string( si, PID_TEMPLATE );
1105     if (!template)
1106         return ERROR_SUCCESS; /* native accepts missing template property */
1107
1108     TRACE("template: %s\n", debugstr_w(template));
1109
1110     p = wcschr( template, ';' );
1111     if (!p)
1112     {
1113         WARN("invalid template string %s\n", debugstr_w(template));
1114         free( template );
1115         return ERROR_PATCH_PACKAGE_INVALID;
1116     }
1117     *p = 0;
1118     platform = template;
1119     if ((q = wcschr( platform, ',' ))) *q = 0;
1120     package->platform = parse_platform( platform );
1121     while (package->platform == PLATFORM_UNRECOGNIZED && q)
1122     {
1123         platform = q + 1;
1124         if ((q = wcschr( platform, ',' ))) *q = 0;
1125         package->platform = parse_platform( platform );
1126     }
1127     if (package->platform == PLATFORM_UNRECOGNIZED)
1128     {
1129         WARN("unknown platform %s\n", debugstr_w(template));
1130         free( template );
1131         return ERROR_INSTALL_PLATFORM_UNSUPPORTED;
1132     }
1133     p++;
1134     if (!*p)
1135     {
1136         free( template );
1137         return ERROR_SUCCESS;
1138     }
1139     count = 1;
1140     for (q = p; (q = wcschr( q, ',' )); q++) count++;
1141
1142     package->langids = malloc( count * sizeof(LANGID) );
1143     if (!package->langids)
1144     {
1145         free( template );
1146         return ERROR_OUTOFMEMORY;
1147     }
1148
1149     i = 0;
1150     while (*p)
1151     {
1152         q = wcschr( p, ',' );
1153         if (q) *q = 0;
1154         package->langids[i] = wcstol( p, NULL, 10 );
1155         if (!q) break;
1156         p = q + 1;
1157         i++;
1158     }
1159     package->num_langids = i + 1;
1160
1161     free( template );
1162     return ERROR_SUCCESS;
1163 }
1164
1165 static UINT validate_package( MSIPACKAGE *package )
1166 {
1167     UINT i;
1168
1169     if (package->platform == PLATFORM_INTEL64)
1170         return ERROR_INSTALL_PLATFORM_UNSUPPORTED;
1171 #ifndef __arm__
1172     if (package->platform == PLATFORM_ARM)
1173         return ERROR_INSTALL_PLATFORM_UNSUPPORTED;
1174 #endif
1175 #ifndef __aarch64__
1176     if (package->platform == PLATFORM_ARM64)
1177         return ERROR_INSTALL_PLATFORM_UNSUPPORTED;
1178 #endif
1179     if (package->platform == PLATFORM_X64)
1180     {
1181         if (!is_64bit && !is_wow64)
1182             return ERROR_INSTALL_PLATFORM_UNSUPPORTED;
1183         if (package->version < 200)
1184             return ERROR_INSTALL_PACKAGE_INVALID;
1185     }
1186     if (!package->num_langids)
1187     {
1188         return ERROR_SUCCESS;
1189     }
1190     for (i = 0; i < package->num_langids; i++)
1191     {
1192         LANGID langid = package->langids[i];
1193
1194         if (PRIMARYLANGID( langid ) == LANG_NEUTRAL)
1195         {
1196             langid = MAKELANGID( PRIMARYLANGID( GetSystemDefaultLangID() ), SUBLANGID( langid ) );
1197         }
1198         if (SUBLANGID( langid ) == SUBLANG_NEUTRAL)
1199         {
1200             langid = MAKELANGID( PRIMARYLANGID( langid ), SUBLANGID( GetSystemDefaultLangID() ) );
1201         }
1202         if (IsValidLocale( langid, LCID_INSTALLED ))
1203             return ERROR_SUCCESS;
1204     }
1205     return ERROR_INSTALL_LANGUAGE_UNSUPPORTED;
1206 }
1207
1208 static WCHAR *get_property( MSIDATABASE *db, const WCHAR *prop )
1209 {
1210     WCHAR query[MAX_PATH];
1211     MSIQUERY *view;
1212     MSIRECORD *rec;
1213     WCHAR *ret = NULL;
1214
1215     swprintf(query, ARRAY_SIZE(query), L"SELECT `Value` FROM `Property` WHERE `Property`='%s'", prop);
1216     if (MSI_DatabaseOpenViewW( db, query, &view ) != ERROR_SUCCESS)
1217     {
1218         return NULL;
1219     }
1220     if (MSI_ViewExecute( view, 0 ) != ERROR_SUCCESS)
1221     {
1222         MSI_ViewClose( view );
1223         msiobj_release( &view->hdr );
1224         return NULL;
1225     }
1226     if (MSI_ViewFetch( view, &rec ) == ERROR_SUCCESS)
1227     {
1228         ret = wcsdup( MSI_RecordGetString( rec, 1 ) );
1229         msiobj_release( &rec->hdr );
1230     }
1231     MSI_ViewClose( view );
1232     msiobj_release( &view->hdr );
1233     return ret;
1234 }
1235
1236 static WCHAR *get_product_code( MSIDATABASE *db )
1237 {
1238     return get_property( db, L"ProductCode" );
1239 }
1240
1241 static WCHAR *get_product_version( MSIDATABASE *db )
1242 {
1243     return get_property( db, L"ProductVersion" );
1244 }
1245
1246 static UINT get_registered_local_package( const WCHAR *product, WCHAR *localfile )
1247 {
1248     MSIINSTALLCONTEXT context;
1249     WCHAR *filename;
1250     HKEY props_key;
1251     UINT r;
1252
1253     r = msi_locate_product( product, &context );
1254     if (r != ERROR_SUCCESS)
1255         return r;
1256
1257     r = MSIREG_OpenInstallProps( product, context, NULL, &props_key, FALSE );
1258     if (r != ERROR_SUCCESS)
1259         return r;
1260
1261     filename = msi_reg_get_val_str( props_key, INSTALLPROPERTY_LOCALPACKAGEW );
1262     RegCloseKey( props_key );
1263     if (!filename)
1264         return ERROR_FUNCTION_FAILED;
1265
1266     lstrcpyW( localfile, filename );
1267     free( filename );
1268     return ERROR_SUCCESS;
1269 }
1270
1271 WCHAR *msi_get_package_code( MSIDATABASE *db )
1272 {
1273     WCHAR *ret;
1274     MSISUMMARYINFO *si;
1275     UINT r;
1276
1277     r = msi_get_suminfo( db->storage, 0, &si );
1278     if (r != ERROR_SUCCESS)
1279     {
1280         r = msi_get_db_suminfo( db, 0, &si );
1281         if (r != ERROR_SUCCESS)
1282         {
1283             WARN("failed to load summary info %u\n", r);
1284             return NULL;
1285         }
1286     }
1287     ret = msi_suminfo_dup_string( si, PID_REVNUMBER );
1288     msiobj_release( &si->hdr );
1289     return ret;
1290 }
1291
1292 static UINT get_local_package( MSIDATABASE *db, WCHAR *localfile )
1293 {
1294     WCHAR *product_code;
1295     UINT r;
1296
1297     if (!(product_code = get_product_code( db )))
1298         return ERROR_INSTALL_PACKAGE_INVALID;
1299     r = get_registered_local_package( product_code, localfile );
1300     free( product_code );
1301     return r;
1302 }
1303
1304 UINT msi_set_original_database_property( MSIDATABASE *db, const WCHAR *package )
1305 {
1306     UINT r;
1307
1308     if (UrlIsW( package, URLIS_URL ))
1309         r = msi_set_property( db, L"OriginalDatabase", package, -1 );
1310     else if (package[0] == '#')
1311         r = msi_set_property( db, L"OriginalDatabase", db->path, -1 );
1312     else
1313     {
1314         DWORD len;
1315         WCHAR *path;
1316
1317         if (!(len = GetFullPathNameW( package, 0, NULL, NULL ))) return GetLastError();
1318         if (!(path = malloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
1319         len = GetFullPathNameW( package, len, path, NULL );
1320         r = msi_set_property( db, L"OriginalDatabase", path, len );
1321         free( path );
1322     }
1323     return r;
1324 }
1325
1326 UINT MSI_OpenPackageW(LPCWSTR szPackage, DWORD dwOptions, MSIPACKAGE **pPackage)
1327 {
1328     MSIDATABASE *db;
1329     MSIPACKAGE *package;
1330     MSIHANDLE handle;
1331     MSIRECORD *data_row, *info_row;
1332     UINT r;
1333     WCHAR localfile[MAX_PATH], cachefile[MAX_PATH];
1334     LPCWSTR file = szPackage;
1335     DWORD index = 0;
1336     MSISUMMARYINFO *si;
1337     BOOL delete_on_close = FALSE;
1338     WCHAR *info_template, *productname, *product_code;
1339     MSIINSTALLCONTEXT context;
1340
1341     TRACE("%s %p\n", debugstr_w(szPackage), pPackage);
1342
1343     MSI_ProcessMessage(NULL, INSTALLMESSAGE_INITIALIZE, 0);
1344
1345     localfile[0] = 0;
1346     if( szPackage[0] == '#' )
1347     {
1348         handle = wcstol(&szPackage[1], NULL, 10);
1349         if (!(db = msihandle2msiinfo(handle, MSIHANDLETYPE_DATABASE)))
1350             return ERROR_INVALID_HANDLE;
1351     }
1352     else
1353     {
1354         WCHAR *product_version = NULL;
1355
1356         if ( UrlIsW( szPackage, URLIS_URL ) )
1357         {
1358             r = msi_download_file( szPackage, cachefile );
1359             if (r != ERROR_SUCCESS)
1360                 return r;
1361
1362             file = cachefile;
1363         }
1364         r = MSI_OpenDatabaseW( file, MSIDBOPEN_READONLY, &db );
1365         if (r != ERROR_SUCCESS)
1366         {
1367             if (GetFileAttributesW( file ) == INVALID_FILE_ATTRIBUTES)
1368                 return ERROR_FILE_NOT_FOUND;
1369             return r;
1370         }
1371         r = get_local_package( db, localfile );
1372         if (r != ERROR_SUCCESS || GetFileAttributesW( localfile ) == INVALID_FILE_ATTRIBUTES)
1373         {
1374             DWORD localfile_attr;
1375
1376             r = msi_create_empty_local_file( localfile, L".msi" );
1377             if (r != ERROR_SUCCESS)
1378             {
1379                 msiobj_release( &db->hdr );
1380                 return r;
1381             }
1382
1383             if (!CopyFileW( file, localfile, FALSE ))
1384             {
1385                 r = GetLastError();
1386                 WARN("unable to copy package %s to %s (%u)\n", debugstr_w(file), debugstr_w(localfile), r);
1387                 DeleteFileW( localfile );
1388                 msiobj_release( &db->hdr );
1389                 return r;
1390             }
1391             delete_on_close = TRUE;
1392
1393             /* Remove read-only bit, we are opening it with write access in MSI_OpenDatabaseW below. */
1394             localfile_attr = GetFileAttributesW( localfile );
1395             if (localfile_attr & FILE_ATTRIBUTE_READONLY)
1396                 SetFileAttributesW( localfile, localfile_attr & ~FILE_ATTRIBUTE_READONLY);
1397         }
1398         else if (dwOptions & WINE_OPENPACKAGEFLAGS_RECACHE)
1399         {
1400             if (!CopyFileW( file, localfile, FALSE ))
1401             {
1402                 r = GetLastError();
1403                 WARN("unable to update cached package (%u)\n", r);
1404                 msiobj_release( &db->hdr );
1405                 return r;
1406             }
1407         }
1408         else
1409             product_version = get_product_version( db );
1410         msiobj_release( &db->hdr );
1411         TRACE("opening package %s\n", debugstr_w( localfile ));
1412         r = MSI_OpenDatabaseW( localfile, MSIDBOPEN_TRANSACT, &db );
1413         if (r != ERROR_SUCCESS)
1414             return r;
1415
1416         if (product_version)
1417         {
1418             WCHAR *cache_version = get_product_version( db );
1419             if (!product_version != !cache_version ||
1420                     (product_version && wcscmp(product_version, cache_version)))
1421             {
1422                 msiobj_release( &db->hdr );
1423                 free( product_version );
1424                 free( cache_version );
1425                 return ERROR_PRODUCT_VERSION;
1426             }
1427             free( product_version );
1428             free( cache_version );
1429         }
1430     }
1431     package = MSI_CreatePackage( db );
1432     msiobj_release( &db->hdr );
1433     if (!package) return ERROR_INSTALL_PACKAGE_INVALID;
1434     package->localfile = wcsdup( localfile );
1435     package->delete_on_close = delete_on_close;
1436
1437     r = msi_get_suminfo( db->storage, 0, &si );
1438     if (r != ERROR_SUCCESS)
1439     {
1440         r = msi_get_db_suminfo( db, 0, &si );
1441         if (r != ERROR_SUCCESS)
1442         {
1443             WARN("failed to load summary info\n");
1444             msiobj_release( &package->hdr );
1445             return ERROR_INSTALL_PACKAGE_INVALID;
1446         }
1447     }
1448     r = parse_suminfo( si, package );
1449     msiobj_release( &si->hdr );
1450     if (r != ERROR_SUCCESS)
1451     {
1452         WARN("failed to parse summary info %u\n", r);
1453         msiobj_release( &package->hdr );
1454         return r;
1455     }
1456     r = validate_package( package );
1457     if (r != ERROR_SUCCESS)
1458     {
1459         msiobj_release( &package->hdr );
1460         return r;
1461     }
1462     msi_set_property( package->db, L"DATABASE", db->path, -1 );
1463     set_installed_prop( package );
1464     msi_set_context( package );
1465
1466     product_code = get_product_code( db );
1467     if (msi_locate_product( product_code, &context ) == ERROR_SUCCESS)
1468     {
1469         TRACE("product already registered\n");
1470         msi_set_property( package->db, L"ProductToBeRegistered", L"1", -1 );
1471     }
1472     free( product_code );
1473
1474     while (1)
1475     {
1476         WCHAR patch_code[GUID_SIZE];
1477         r = MsiEnumPatchesExW( package->ProductCode, NULL, package->Context,
1478                                MSIPATCHSTATE_APPLIED, index, patch_code, NULL, NULL, NULL, NULL );
1479         if (r != ERROR_SUCCESS)
1480             break;
1481
1482         TRACE("found registered patch %s\n", debugstr_w(patch_code));
1483
1484         r = msi_apply_registered_patch( package, patch_code );
1485         if (r != ERROR_SUCCESS)
1486         {
1487             ERR("registered patch failed to apply %u\n", r);
1488             msiobj_release( &package->hdr );
1489             return r;
1490         }
1491         index++;
1492     }
1493     if (index) msi_adjust_privilege_properties( package );
1494
1495     r = msi_set_original_database_property( package->db, szPackage );
1496     if (r != ERROR_SUCCESS)
1497     {
1498         msiobj_release( &package->hdr );
1499         return r;
1500     }
1501     if (gszLogFile)
1502         package->log_file = CreateFileW( gszLogFile, GENERIC_WRITE, FILE_SHARE_WRITE, NULL,
1503                                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
1504
1505     /* FIXME: when should these messages be sent? */
1506     data_row = MSI_CreateRecord(3);
1507     if (!data_row)
1508         return ERROR_OUTOFMEMORY;
1509     MSI_RecordSetStringW(data_row, 0, NULL);
1510     MSI_RecordSetInteger(data_row, 1, 0);
1511     MSI_RecordSetInteger(data_row, 2, package->num_langids ? package->langids[0] : 0);
1512     MSI_RecordSetInteger(data_row, 3, msi_get_string_table_codepage(package->db->strings));
1513     MSI_ProcessMessageVerbatim(package, INSTALLMESSAGE_COMMONDATA, data_row);
1514
1515     info_row = MSI_CreateRecord(0);
1516     if (!info_row)
1517     {
1518         msiobj_release(&data_row->hdr);
1519         return ERROR_OUTOFMEMORY;
1520     }
1521     info_template = msi_get_error_message(package->db, MSIERR_INFO_LOGGINGSTART);
1522     MSI_RecordSetStringW(info_row, 0, info_template);
1523     free(info_template);
1524     MSI_ProcessMessage(package, INSTALLMESSAGE_INFO|MB_ICONHAND, info_row);
1525
1526     MSI_ProcessMessage(package, INSTALLMESSAGE_COMMONDATA, data_row);
1527
1528     productname = msi_dup_property(package->db, INSTALLPROPERTY_PRODUCTNAMEW);
1529     MSI_RecordSetInteger(data_row, 1, 1);
1530     MSI_RecordSetStringW(data_row, 2, productname);
1531     MSI_RecordSetStringW(data_row, 3, NULL);
1532     MSI_ProcessMessage(package, INSTALLMESSAGE_COMMONDATA, data_row);
1533
1534     free(productname);
1535     msiobj_release(&info_row->hdr);
1536     msiobj_release(&data_row->hdr);
1537
1538     *pPackage = package;
1539     return ERROR_SUCCESS;
1540 }
1541
1542 UINT WINAPI MsiOpenPackageExW( const WCHAR *szPackage, DWORD dwOptions, MSIHANDLE *phPackage )
1543 {
1544     MSIPACKAGE *package = NULL;
1545     UINT ret;
1546
1547     TRACE( "%s, %#lx, %p\n", debugstr_w(szPackage), dwOptions, phPackage );
1548
1549     if( !szPackage || !phPackage )
1550         return ERROR_INVALID_PARAMETER;
1551
1552     if ( !*szPackage )
1553     {
1554         FIXME("Should create an empty database and package\n");
1555         return ERROR_FUNCTION_FAILED;
1556     }
1557
1558     if( dwOptions )
1559         FIXME( "dwOptions %#lx not supported\n", dwOptions );
1560
1561     ret = MSI_OpenPackageW( szPackage, 0, &package );
1562     if( ret == ERROR_SUCCESS )
1563     {
1564         *phPackage = alloc_msihandle( &package->hdr );
1565         if (! *phPackage)
1566             ret = ERROR_NOT_ENOUGH_MEMORY;
1567         msiobj_release( &package->hdr );
1568     }
1569     else
1570         MSI_ProcessMessage(NULL, INSTALLMESSAGE_TERMINATE, 0);
1571
1572     return ret;
1573 }
1574
1575 UINT WINAPI MsiOpenPackageW(LPCWSTR szPackage, MSIHANDLE *phPackage)
1576 {
1577     return MsiOpenPackageExW( szPackage, 0, phPackage );
1578 }
1579
1580 UINT WINAPI MsiOpenPackageExA(LPCSTR szPackage, DWORD dwOptions, MSIHANDLE *phPackage)
1581 {
1582     LPWSTR szwPack = NULL;
1583     UINT ret;
1584
1585     if( szPackage )
1586     {
1587         szwPack = strdupAtoW( szPackage );
1588         if( !szwPack )
1589             return ERROR_OUTOFMEMORY;
1590     }
1591
1592     ret = MsiOpenPackageExW( szwPack, dwOptions, phPackage );
1593
1594     free( szwPack );
1595
1596     return ret;
1597 }
1598
1599 UINT WINAPI MsiOpenPackageA(LPCSTR szPackage, MSIHANDLE *phPackage)
1600 {
1601     return MsiOpenPackageExA( szPackage, 0, phPackage );
1602 }
1603
1604 MSIHANDLE WINAPI MsiGetActiveDatabase( MSIHANDLE hInstall )
1605 {
1606     MSIPACKAGE *package;
1607     MSIHANDLE handle = 0;
1608     MSIHANDLE remote;
1609
1610     TRACE( "%lu\n", hInstall );
1611
1612     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE);
1613     if( package)
1614     {
1615         handle = alloc_msihandle( &package->db->hdr );
1616         msiobj_release( &package->hdr );
1617     }
1618     else if ((remote = msi_get_remote(hInstall)))
1619     {
1620         __TRY
1621         {
1622             handle = remote_GetActiveDatabase(remote);
1623             handle = alloc_msi_remote_handle(handle);
1624         }
1625         __EXCEPT(rpc_filter)
1626         {
1627             handle = 0;
1628         }
1629         __ENDTRY
1630     }
1631
1632     return handle;
1633 }
1634
1635 static INT internal_ui_handler(MSIPACKAGE *package, INSTALLMESSAGE eMessageType, MSIRECORD *record, LPCWSTR message)
1636 {
1637     if (!package || (package->ui_level & INSTALLUILEVEL_MASK) == INSTALLUILEVEL_NONE)
1638         return 0;
1639
1640     /* todo: check if message needs additional styles (topmost/foreground/modality?) */
1641
1642     switch (eMessageType & 0xff000000)
1643     {
1644     case INSTALLMESSAGE_FATALEXIT:
1645     case INSTALLMESSAGE_ERROR:
1646     case INSTALLMESSAGE_OUTOFDISKSPACE:
1647         if (package->ui_level & INSTALLUILEVEL_PROGRESSONLY) return 0;
1648         if (!(eMessageType & MB_ICONMASK))
1649             eMessageType |= MB_ICONEXCLAMATION;
1650         return MessageBoxW(gUIhwnd, message, L"Windows Installer", eMessageType & 0x00ffffff);
1651     case INSTALLMESSAGE_WARNING:
1652         if (package->ui_level & INSTALLUILEVEL_PROGRESSONLY) return 0;
1653         if (!(eMessageType & MB_ICONMASK))
1654             eMessageType |= MB_ICONASTERISK;
1655         return MessageBoxW(gUIhwnd, message, L"Windows Installer", eMessageType & 0x00ffffff);
1656     case INSTALLMESSAGE_USER:
1657         if (package->ui_level & INSTALLUILEVEL_PROGRESSONLY) return 0;
1658         if (!(eMessageType & MB_ICONMASK))
1659             eMessageType |= MB_USERICON;
1660         return MessageBoxW(gUIhwnd, message, L"Windows Installer", eMessageType & 0x00ffffff);
1661     case INSTALLMESSAGE_INFO:
1662     case INSTALLMESSAGE_INITIALIZE:
1663     case INSTALLMESSAGE_TERMINATE:
1664     case INSTALLMESSAGE_INSTALLSTART:
1665     case INSTALLMESSAGE_INSTALLEND:
1666         return 0;
1667     case INSTALLMESSAGE_SHOWDIALOG:
1668     {
1669         LPWSTR dialog = msi_dup_record_field(record, 0);
1670         INT rc = ACTION_DialogBox(package, dialog);
1671         free(dialog);
1672         return rc;
1673     }
1674     case INSTALLMESSAGE_ACTIONSTART:
1675     {
1676         LPWSTR deformatted;
1677         MSIRECORD *uirow = MSI_CreateRecord(1);
1678         if (!uirow) return -1;
1679         deformat_string(package, MSI_RecordGetString(record, 2), &deformatted);
1680         MSI_RecordSetStringW(uirow, 1, deformatted);
1681         msi_event_fire(package, L"ActionText", uirow);
1682
1683         free(deformatted);
1684         msiobj_release(&uirow->hdr);
1685         return 1;
1686     }
1687     case INSTALLMESSAGE_ACTIONDATA:
1688     {
1689         MSIRECORD *uirow = MSI_CreateRecord(1);
1690         if (!uirow) return -1;
1691         MSI_RecordSetStringW(uirow, 1, message);
1692         msi_event_fire(package, L"ActionData", uirow);
1693         msiobj_release(&uirow->hdr);
1694
1695         if (package->action_progress_increment)
1696         {
1697             uirow = MSI_CreateRecord(2);
1698             if (!uirow) return -1;
1699             MSI_RecordSetInteger(uirow, 1, 2);
1700             MSI_RecordSetInteger(uirow, 2, package->action_progress_increment);
1701             msi_event_fire(package, L"SetProgress", uirow);
1702             msiobj_release(&uirow->hdr);
1703         }
1704         return 1;
1705     }
1706     case INSTALLMESSAGE_PROGRESS:
1707         msi_event_fire(package, L"SetProgress", record);
1708         return 1;
1709     case INSTALLMESSAGE_COMMONDATA:
1710         switch (MSI_RecordGetInteger(record, 1))
1711         {
1712         case 0:
1713         case 1:
1714             /* do nothing */
1715             return 0;
1716         default:
1717             /* fall through */
1718             ;
1719         }
1720     default:
1721         FIXME("internal UI not implemented for message 0x%08x (UI level = %x)\n", eMessageType, package->ui_level);
1722         return 0;
1723     }
1724 }
1725
1726 static const struct
1727 {
1728     int id;
1729     const WCHAR *text;
1730 }
1731 internal_errors[] =
1732 {
1733     {2726, L"DEBUG: Error [1]:  Action not found: [2]"},
1734     {0}
1735 };
1736
1737 static LPCWSTR get_internal_error_message(int error)
1738 {
1739     int i = 0;
1740
1741     while (internal_errors[i].id != 0)
1742     {
1743         if (internal_errors[i].id == error)
1744             return internal_errors[i].text;
1745         i++;
1746     }
1747
1748     FIXME("missing error message %d\n", error);
1749     return NULL;
1750 }
1751
1752 /* Returned string must be freed */
1753 LPWSTR msi_get_error_message(MSIDATABASE *db, int error)
1754 {
1755     MSIRECORD *record;
1756     LPWSTR ret = NULL;
1757
1758     if ((record = MSI_QueryGetRecord(db, L"SELECT `Message` FROM `Error` WHERE `Error` = %d", error)))
1759     {
1760         ret = msi_dup_record_field(record, 1);
1761         msiobj_release(&record->hdr);
1762     }
1763     else if (error < 2000)
1764     {
1765         int len = LoadStringW(msi_hInstance, IDS_ERROR_BASE + error, (LPWSTR) &ret, 0);
1766         if (len)
1767         {
1768             ret = malloc((len + 1) * sizeof(WCHAR));
1769             LoadStringW(msi_hInstance, IDS_ERROR_BASE + error, ret, len + 1);
1770         }
1771         else
1772             ret = NULL;
1773     }
1774
1775     return ret;
1776 }
1777
1778 INT MSI_ProcessMessageVerbatim(MSIPACKAGE *package, INSTALLMESSAGE eMessageType, MSIRECORD *record)
1779 {
1780     LPWSTR message = {0};
1781     DWORD len;
1782     DWORD log_type = 1 << (eMessageType >> 24);
1783     UINT res;
1784     INT rc = 0;
1785     char *msg;
1786
1787     TRACE("%x\n", eMessageType);
1788     if (TRACE_ON(msi)) dump_record(record);
1789
1790     if (!package || !record)
1791         message = NULL;
1792     else {
1793         res = MSI_FormatRecordW(package, record, message, &len);
1794         if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
1795             return res;
1796         len++;
1797         message = malloc(len * sizeof(WCHAR));
1798         if (!message) return ERROR_OUTOFMEMORY;
1799         MSI_FormatRecordW(package, record, message, &len);
1800     }
1801
1802     /* convert it to ANSI */
1803     len = WideCharToMultiByte( CP_ACP, 0, message, -1, NULL, 0, NULL, NULL );
1804     msg = malloc( len );
1805     WideCharToMultiByte( CP_ACP, 0, message, -1, msg, len, NULL, NULL );
1806
1807     if (gUIHandlerRecord && (gUIFilterRecord & log_type))
1808     {
1809         MSIHANDLE rec = alloc_msihandle(&record->hdr);
1810         TRACE( "calling UI handler %p(pvContext = %p, iMessageType = %#x, hRecord = %lu)\n",
1811                gUIHandlerRecord, gUIContextRecord, eMessageType, rec );
1812         rc = gUIHandlerRecord( gUIContextRecord, eMessageType, rec );
1813         MsiCloseHandle( rec );
1814     }
1815     if (!rc && gUIHandlerW && (gUIFilter & log_type))
1816     {
1817         TRACE( "calling UI handler %p(pvContext = %p, iMessageType = %#x, szMessage = %s)\n",
1818                gUIHandlerW, gUIContext, eMessageType, debugstr_w(message) );
1819         rc = gUIHandlerW( gUIContext, eMessageType, message );
1820     }
1821     else if (!rc && gUIHandlerA && (gUIFilter & log_type))
1822     {
1823         TRACE( "calling UI handler %p(pvContext = %p, iMessageType = %#x, szMessage = %s)\n",
1824                gUIHandlerA, gUIContext, eMessageType, debugstr_a(msg) );
1825         rc = gUIHandlerA( gUIContext, eMessageType, msg );
1826     }
1827
1828     if (!rc)
1829         rc = internal_ui_handler(package, eMessageType, record, message);
1830
1831     if (!rc && package && package->log_file != INVALID_HANDLE_VALUE &&
1832         (eMessageType & 0xff000000) != INSTALLMESSAGE_PROGRESS)
1833     {
1834         DWORD written;
1835         WriteFile( package->log_file, msg, len - 1, &written, NULL );
1836         WriteFile( package->log_file, "\n", 1, &written, NULL );
1837     }
1838     free( msg );
1839     free( message );
1840
1841     return rc;
1842 }
1843
1844 INT MSI_ProcessMessage( MSIPACKAGE *package, INSTALLMESSAGE eMessageType, MSIRECORD *record )
1845 {
1846     switch (eMessageType & 0xff000000)
1847     {
1848     case INSTALLMESSAGE_FATALEXIT:
1849     case INSTALLMESSAGE_ERROR:
1850     case INSTALLMESSAGE_WARNING:
1851     case INSTALLMESSAGE_USER:
1852     case INSTALLMESSAGE_INFO:
1853     case INSTALLMESSAGE_OUTOFDISKSPACE:
1854         if (MSI_RecordGetInteger(record, 1) != MSI_NULL_INTEGER)
1855         {
1856             /* error message */
1857
1858             LPWSTR template;
1859             LPWSTR template_rec = NULL, template_prefix = NULL;
1860             int error = MSI_RecordGetInteger(record, 1);
1861
1862             if (MSI_RecordIsNull(record, 0))
1863             {
1864                 if (error >= 32)
1865                 {
1866                     template_rec = msi_get_error_message(package->db, error);
1867
1868                     if (!template_rec && error >= 2000)
1869                     {
1870                         /* internal error, not localized */
1871                         if ((template_rec = (LPWSTR) get_internal_error_message(error)))
1872                         {
1873                             MSI_RecordSetStringW(record, 0, template_rec);
1874                             MSI_ProcessMessageVerbatim(package, INSTALLMESSAGE_INFO, record);
1875                         }
1876                         template_rec = msi_get_error_message(package->db, MSIERR_INSTALLERROR);
1877                         MSI_RecordSetStringW(record, 0, template_rec);
1878                         MSI_ProcessMessageVerbatim(package, eMessageType, record);
1879                         free(template_rec);
1880                         return 0;
1881                     }
1882                 }
1883             }
1884             else
1885                 template_rec = msi_dup_record_field(record, 0);
1886
1887             template_prefix = msi_get_error_message(package->db, eMessageType >> 24);
1888             if (!template_prefix) template_prefix = wcsdup(L"");
1889
1890             if (!template_rec)
1891             {
1892                 /* always returns 0 */
1893                 MSI_RecordSetStringW(record, 0, template_prefix);
1894                 MSI_ProcessMessageVerbatim(package, eMessageType, record);
1895                 free(template_prefix);
1896                 return 0;
1897             }
1898
1899             template = malloc((wcslen(template_rec) + wcslen(template_prefix) + 1) * sizeof(WCHAR));
1900             if (!template) return ERROR_OUTOFMEMORY;
1901
1902             lstrcpyW(template, template_prefix);
1903             lstrcatW(template, template_rec);
1904             MSI_RecordSetStringW(record, 0, template);
1905
1906             free(template_prefix);
1907             free(template_rec);
1908             free(template);
1909         }
1910         break;
1911     case INSTALLMESSAGE_ACTIONSTART:
1912     {
1913         WCHAR *template = msi_get_error_message(package->db, MSIERR_ACTIONSTART);
1914         MSI_RecordSetStringW(record, 0, template);
1915         free(template);
1916
1917         free(package->LastAction);
1918         free(package->LastActionTemplate);
1919         package->LastAction = msi_dup_record_field(record, 1);
1920         if (!package->LastAction) package->LastAction = wcsdup(L"");
1921         package->LastActionTemplate = msi_dup_record_field(record, 3);
1922         break;
1923     }
1924     case INSTALLMESSAGE_ACTIONDATA:
1925         if (package->LastAction && package->LastActionTemplate)
1926         {
1927             size_t len = lstrlenW(package->LastAction) + lstrlenW(package->LastActionTemplate) + 7;
1928             WCHAR *template = malloc(len * sizeof(WCHAR));
1929             if (!template) return ERROR_OUTOFMEMORY;
1930             swprintf(template, len, L"{{%s: }}%s", package->LastAction, package->LastActionTemplate);
1931             MSI_RecordSetStringW(record, 0, template);
1932             free(template);
1933         }
1934         break;
1935     case INSTALLMESSAGE_COMMONDATA:
1936     {
1937         WCHAR *template = msi_get_error_message(package->db, MSIERR_COMMONDATA);
1938         MSI_RecordSetStringW(record, 0, template);
1939         free(template);
1940     }
1941     break;
1942     }
1943
1944     return MSI_ProcessMessageVerbatim(package, eMessageType, record);
1945 }
1946
1947 INT WINAPI MsiProcessMessage( MSIHANDLE hInstall, INSTALLMESSAGE eMessageType,
1948                               MSIHANDLE hRecord)
1949 {
1950     UINT ret = ERROR_INVALID_HANDLE;
1951     MSIPACKAGE *package = NULL;
1952     MSIRECORD *record = NULL;
1953
1954     if ((eMessageType & 0xff000000) == INSTALLMESSAGE_INITIALIZE ||
1955         (eMessageType & 0xff000000) == INSTALLMESSAGE_TERMINATE)
1956         return -1;
1957
1958     if ((eMessageType & 0xff000000) == INSTALLMESSAGE_COMMONDATA &&
1959         MsiRecordGetInteger(hRecord, 1) != 2)
1960         return -1;
1961
1962     record = msihandle2msiinfo(hRecord, MSIHANDLETYPE_RECORD);
1963     if (!record)
1964         return ERROR_INVALID_HANDLE;
1965
1966     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
1967     if( !package )
1968     {
1969         MSIHANDLE remote;
1970
1971         if (!(remote = msi_get_remote(hInstall)))
1972             return ERROR_INVALID_HANDLE;
1973
1974         __TRY
1975         {
1976             ret = remote_ProcessMessage(remote, eMessageType, (struct wire_record *)&record->count);
1977         }
1978         __EXCEPT(rpc_filter)
1979         {
1980             ret = GetExceptionCode();
1981         }
1982         __ENDTRY
1983
1984         msiobj_release(&record->hdr);
1985         return ret;
1986     }
1987
1988     ret = MSI_ProcessMessage( package, eMessageType, record );
1989
1990     msiobj_release( &record->hdr );
1991     msiobj_release( &package->hdr );
1992     return ret;
1993 }
1994
1995 /* property code */
1996
1997 UINT WINAPI MsiSetPropertyA( MSIHANDLE hInstall, LPCSTR szName, LPCSTR szValue )
1998 {
1999     LPWSTR szwName = NULL, szwValue = NULL;
2000     UINT r = ERROR_OUTOFMEMORY;
2001
2002     szwName = strdupAtoW( szName );
2003     if( szName && !szwName )
2004         goto end;
2005
2006     szwValue = strdupAtoW( szValue );
2007     if( szValue && !szwValue )
2008         goto end;
2009
2010     r = MsiSetPropertyW( hInstall, szwName, szwValue);
2011
2012 end:
2013     free( szwName );
2014     free( szwValue );
2015
2016     return r;
2017 }
2018
2019 void msi_reset_source_folders( MSIPACKAGE *package )
2020 {
2021     MSIFOLDER *folder;
2022
2023     LIST_FOR_EACH_ENTRY( folder, &package->folders, MSIFOLDER, entry )
2024     {
2025         free( folder->ResolvedSource );
2026         folder->ResolvedSource = NULL;
2027     }
2028 }
2029
2030 UINT msi_set_property( MSIDATABASE *db, const WCHAR *name, const WCHAR *value, int len )
2031 {
2032     MSIQUERY *view;
2033     MSIRECORD *row = NULL;
2034     DWORD sz = 0;
2035     WCHAR query[1024];
2036     UINT rc;
2037
2038     TRACE("%p %s %s %d\n", db, debugstr_w(name), debugstr_wn(value, len), len);
2039
2040     if (!name)
2041         return ERROR_INVALID_PARAMETER;
2042
2043     /* this one is weird... */
2044     if (!name[0])
2045         return value ? ERROR_FUNCTION_FAILED : ERROR_SUCCESS;
2046
2047     if (value && len < 0) len = lstrlenW( value );
2048
2049     rc = msi_get_property( db, name, 0, &sz );
2050     if (!value || (!*value && !len))
2051     {
2052         swprintf( query, ARRAY_SIZE(query), L"DELETE FROM `_Property` WHERE `_Property` = '%s'", name );
2053     }
2054     else if (rc == ERROR_MORE_DATA || rc == ERROR_SUCCESS)
2055     {
2056         swprintf( query, ARRAY_SIZE(query), L"UPDATE `_Property` SET `Value` = ? WHERE `_Property` = '%s'", name );
2057         row = MSI_CreateRecord(1);
2058         msi_record_set_string( row, 1, value, len );
2059     }
2060     else
2061     {
2062         lstrcpyW( query, L"INSERT INTO `_Property` (`_Property`,`Value`) VALUES (?,?)" );
2063         row = MSI_CreateRecord(2);
2064         msi_record_set_string( row, 1, name, -1 );
2065         msi_record_set_string( row, 2, value, len );
2066     }
2067
2068     rc = MSI_DatabaseOpenViewW(db, query, &view);
2069     if (rc == ERROR_SUCCESS)
2070     {
2071         rc = MSI_ViewExecute(view, row);
2072         MSI_ViewClose(view);
2073         msiobj_release(&view->hdr);
2074     }
2075     if (row) msiobj_release(&row->hdr);
2076     return rc;
2077 }
2078
2079 UINT WINAPI MsiSetPropertyW( MSIHANDLE hInstall, LPCWSTR szName, LPCWSTR szValue)
2080 {
2081     MSIPACKAGE *package;
2082     UINT ret;
2083
2084     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE);
2085     if( !package )
2086     {
2087         MSIHANDLE remote;
2088
2089         if (!(remote = msi_get_remote(hInstall)))
2090             return ERROR_INVALID_HANDLE;
2091
2092         __TRY
2093         {
2094             ret = remote_SetProperty(remote, szName, szValue);
2095         }
2096         __EXCEPT(rpc_filter)
2097         {
2098             ret = GetExceptionCode();
2099         }
2100         __ENDTRY
2101
2102         return ret;
2103     }
2104
2105     ret = msi_set_property( package->db, szName, szValue, -1 );
2106     if (ret == ERROR_SUCCESS && !wcscmp( szName, L"SourceDir" ))
2107         msi_reset_source_folders( package );
2108
2109     msiobj_release( &package->hdr );
2110     return ret;
2111 }
2112
2113 static MSIRECORD *get_property_row( MSIDATABASE *db, const WCHAR *name )
2114 {
2115     MSIRECORD *rec, *row = NULL;
2116     MSIQUERY *view;
2117     UINT r;
2118     WCHAR *buffer;
2119     int length;
2120
2121     if (!name || !*name)
2122         return NULL;
2123
2124     if (!wcscmp(name, L"Date"))
2125     {
2126         length = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, NULL, 0);
2127         if (!length)
2128             return NULL;
2129         buffer = malloc(length * sizeof(WCHAR));
2130         GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, buffer, length);
2131
2132         row = MSI_CreateRecord(1);
2133         if (!row)
2134         {
2135             free(buffer);
2136             return NULL;
2137         }
2138         MSI_RecordSetStringW(row, 1, buffer);
2139         free(buffer);
2140         return row;
2141     }
2142     else if (!wcscmp(name, L"Time"))
2143     {
2144         length = GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOTIMEMARKER, NULL, NULL, NULL, 0);
2145         if (!length)
2146             return NULL;
2147         buffer = malloc(length * sizeof(WCHAR));
2148         GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOTIMEMARKER, NULL, NULL, buffer, length);
2149
2150         row = MSI_CreateRecord(1);
2151         if (!row)
2152         {
2153             free(buffer);
2154             return NULL;
2155         }
2156         MSI_RecordSetStringW(row, 1, buffer);
2157         free(buffer);
2158         return row;
2159     }
2160
2161     rec = MSI_CreateRecord(1);
2162     if (!rec)
2163         return NULL;
2164
2165     MSI_RecordSetStringW(rec, 1, name);
2166
2167     r = MSI_DatabaseOpenViewW(db, L"SELECT `Value` FROM `_Property` WHERE `_Property`=?", &view);
2168     if (r == ERROR_SUCCESS)
2169     {
2170         MSI_ViewExecute(view, rec);
2171         MSI_ViewFetch(view, &row);
2172         MSI_ViewClose(view);
2173         msiobj_release(&view->hdr);
2174     }
2175     msiobj_release(&rec->hdr);
2176     return row;
2177 }
2178
2179 /* internal function, not compatible with MsiGetPropertyW */
2180 UINT msi_get_property( MSIDATABASE *db, LPCWSTR szName,
2181                        LPWSTR szValueBuf, LPDWORD pchValueBuf )
2182 {
2183     MSIRECORD *row;
2184     UINT rc = ERROR_FUNCTION_FAILED;
2185
2186     TRACE("%p %s %p %p\n", db, debugstr_w(szName), szValueBuf, pchValueBuf);
2187
2188     row = get_property_row( db, szName );
2189
2190     if (*pchValueBuf > 0)
2191         szValueBuf[0] = 0;
2192
2193     if (row)
2194     {
2195         rc = MSI_RecordGetStringW(row, 1, szValueBuf, pchValueBuf);
2196         msiobj_release(&row->hdr);
2197     }
2198
2199     if (rc == ERROR_SUCCESS)
2200         TRACE("returning %s for property %s\n", debugstr_wn(szValueBuf, *pchValueBuf),
2201             debugstr_w(szName));
2202     else if (rc == ERROR_MORE_DATA)
2203         TRACE( "need %lu sized buffer for %s\n", *pchValueBuf, debugstr_w(szName) );
2204     else
2205     {
2206         *pchValueBuf = 0;
2207         TRACE("property %s not found\n", debugstr_w(szName));
2208     }
2209
2210     return rc;
2211 }
2212
2213 LPWSTR msi_dup_property(MSIDATABASE *db, LPCWSTR prop)
2214 {
2215     DWORD sz = 0;
2216     LPWSTR str;
2217     UINT r;
2218
2219     r = msi_get_property(db, prop, NULL, &sz);
2220     if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
2221         return NULL;
2222
2223     sz++;
2224     str = malloc(sz * sizeof(WCHAR));
2225     r = msi_get_property(db, prop, str, &sz);
2226     if (r != ERROR_SUCCESS)
2227     {
2228         free(str);
2229         str = NULL;
2230     }
2231
2232     return str;
2233 }
2234
2235 int msi_get_property_int( MSIDATABASE *db, LPCWSTR prop, int def )
2236 {
2237     LPWSTR str = msi_dup_property( db, prop );
2238     int val = str ? wcstol(str, NULL, 10) : def;
2239     free(str);
2240     return val;
2241 }
2242
2243 UINT WINAPI MsiGetPropertyA(MSIHANDLE hinst, const char *name, char *buf, DWORD *sz)
2244 {
2245     const WCHAR *value = L"";
2246     MSIPACKAGE *package;
2247     MSIRECORD *row;
2248     WCHAR *nameW;
2249     int len = 0;
2250     UINT r;
2251
2252     if (!name)
2253         return ERROR_INVALID_PARAMETER;
2254
2255     if (!(nameW = strdupAtoW(name)))
2256         return ERROR_OUTOFMEMORY;
2257
2258     package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
2259     if (!package)
2260     {
2261         WCHAR *value = NULL, *tmp;
2262         MSIHANDLE remote;
2263         DWORD len;
2264
2265         if (!(remote = msi_get_remote(hinst)))
2266         {
2267             free(nameW);
2268             return ERROR_INVALID_HANDLE;
2269         }
2270
2271         __TRY
2272         {
2273             r = remote_GetProperty(remote, nameW, &value, &len);
2274         }
2275         __EXCEPT(rpc_filter)
2276         {
2277             r = GetExceptionCode();
2278         }
2279         __ENDTRY
2280
2281         free(nameW);
2282
2283         if (!r)
2284         {
2285             /* String might contain embedded nulls.
2286              * Native returns the correct size but truncates the string. */
2287             tmp = calloc(1, (len + 1) * sizeof(WCHAR));
2288             if (!tmp)
2289             {
2290                 midl_user_free(value);
2291                 return ERROR_OUTOFMEMORY;
2292             }
2293             lstrcpyW(tmp, value);
2294
2295             r = msi_strncpyWtoA(tmp, len, buf, sz, TRUE);
2296
2297             free(tmp);
2298         }
2299         midl_user_free(value);
2300         return r;
2301     }
2302
2303     row = get_property_row(package->db, nameW);
2304     if (row)
2305         value = msi_record_get_string(row, 1, &len);
2306
2307     r = msi_strncpyWtoA(value, len, buf, sz, FALSE);
2308
2309     free(nameW);
2310     if (row) msiobj_release(&row->hdr);
2311     msiobj_release(&package->hdr);
2312     return r;
2313 }
2314
2315 UINT WINAPI MsiGetPropertyW(MSIHANDLE hinst, const WCHAR *name, WCHAR *buf, DWORD *sz)
2316 {
2317     const WCHAR *value = L"";
2318     MSIPACKAGE *package;
2319     MSIRECORD *row;
2320     int len = 0;
2321     UINT r;
2322
2323     if (!name)
2324         return ERROR_INVALID_PARAMETER;
2325
2326     package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
2327     if (!package)
2328     {
2329         WCHAR *value = NULL, *tmp;
2330         MSIHANDLE remote;
2331         DWORD len;
2332
2333         if (!(remote = msi_get_remote(hinst)))
2334             return ERROR_INVALID_HANDLE;
2335
2336         __TRY
2337         {
2338             r = remote_GetProperty(remote, name, &value, &len);
2339         }
2340         __EXCEPT(rpc_filter)
2341         {
2342             r = GetExceptionCode();
2343         }
2344         __ENDTRY
2345
2346         if (!r)
2347         {
2348             /* String might contain embedded nulls.
2349              * Native returns the correct size but truncates the string. */
2350             tmp = calloc(1, (len + 1) * sizeof(WCHAR));
2351             if (!tmp)
2352             {
2353                 midl_user_free(value);
2354                 return ERROR_OUTOFMEMORY;
2355             }
2356             lstrcpyW(tmp, value);
2357
2358             r = msi_strncpyW(tmp, len, buf, sz);
2359
2360             free(tmp);
2361         }
2362         midl_user_free(value);
2363         return r;
2364     }
2365
2366     row = get_property_row(package->db, name);
2367     if (row)
2368         value = msi_record_get_string(row, 1, &len);
2369
2370     r = msi_strncpyW(value, len, buf, sz);
2371
2372     if (row) msiobj_release(&row->hdr);
2373     msiobj_release(&package->hdr);
2374     return r;
2375 }
2376
2377 MSIHANDLE __cdecl s_remote_GetActiveDatabase(MSIHANDLE hinst)
2378 {
2379     return MsiGetActiveDatabase(hinst);
2380 }
2381
2382 UINT __cdecl s_remote_GetProperty(MSIHANDLE hinst, LPCWSTR property, LPWSTR *value, DWORD *size)
2383 {
2384     WCHAR empty[1];
2385     UINT r;
2386
2387     *size = 0;
2388     r = MsiGetPropertyW(hinst, property, empty, size);
2389     if (r == ERROR_MORE_DATA)
2390     {
2391         ++*size;
2392         *value = midl_user_allocate(*size * sizeof(WCHAR));
2393         if (!*value)
2394             return ERROR_OUTOFMEMORY;
2395         r = MsiGetPropertyW(hinst, property, *value, size);
2396     }
2397     return r;
2398 }
2399
2400 UINT __cdecl s_remote_SetProperty(MSIHANDLE hinst, LPCWSTR property, LPCWSTR value)
2401 {
2402     return MsiSetPropertyW(hinst, property, value);
2403 }
2404
2405 int __cdecl s_remote_ProcessMessage(MSIHANDLE hinst, INSTALLMESSAGE message, struct wire_record *remote_rec)
2406 {
2407     MSIHANDLE rec;
2408     int ret;
2409     UINT r;
2410
2411     if ((r = unmarshal_record(remote_rec, &rec)))
2412         return r;
2413
2414     ret = MsiProcessMessage(hinst, message, rec);
2415
2416     MsiCloseHandle(rec);
2417     return ret;
2418 }
2419
2420 UINT __cdecl s_remote_DoAction(MSIHANDLE hinst, LPCWSTR action)
2421 {
2422     return MsiDoActionW(hinst, action);
2423 }
2424
2425 UINT __cdecl s_remote_Sequence(MSIHANDLE hinst, LPCWSTR table, int sequence)
2426 {
2427     return MsiSequenceW(hinst, table, sequence);
2428 }
2429
2430 UINT __cdecl s_remote_GetTargetPath(MSIHANDLE hinst, LPCWSTR folder, LPWSTR *value)
2431 {
2432     WCHAR empty[1];
2433     DWORD size = 0;
2434     UINT r;
2435
2436     r = MsiGetTargetPathW(hinst, folder, empty, &size);
2437     if (r == ERROR_MORE_DATA)
2438     {
2439         *value = midl_user_allocate(++size * sizeof(WCHAR));
2440         if (!*value)
2441             return ERROR_OUTOFMEMORY;
2442         r = MsiGetTargetPathW(hinst, folder, *value, &size);
2443     }
2444     return r;
2445 }
2446
2447 UINT __cdecl s_remote_SetTargetPath(MSIHANDLE hinst, LPCWSTR folder, LPCWSTR value)
2448 {
2449     return MsiSetTargetPathW(hinst, folder, value);
2450 }
2451
2452 UINT __cdecl s_remote_GetSourcePath(MSIHANDLE hinst, LPCWSTR folder, LPWSTR *value)
2453 {
2454     WCHAR empty[1];
2455     DWORD size = 1;
2456     UINT r;
2457
2458     r = MsiGetSourcePathW(hinst, folder, empty, &size);
2459     if (r == ERROR_MORE_DATA)
2460     {
2461         *value = midl_user_allocate(++size * sizeof(WCHAR));
2462         if (!*value)
2463             return ERROR_OUTOFMEMORY;
2464         r = MsiGetSourcePathW(hinst, folder, *value, &size);
2465     }
2466     return r;
2467 }
2468
2469 BOOL __cdecl s_remote_GetMode(MSIHANDLE hinst, MSIRUNMODE mode)
2470 {
2471     return MsiGetMode(hinst, mode);
2472 }
2473
2474 UINT __cdecl s_remote_SetMode(MSIHANDLE hinst, MSIRUNMODE mode, BOOL state)
2475 {
2476     return MsiSetMode(hinst, mode, state);
2477 }
2478
2479 UINT __cdecl s_remote_GetFeatureState(MSIHANDLE hinst, LPCWSTR feature,
2480                                     INSTALLSTATE *installed, INSTALLSTATE *action)
2481 {
2482     return MsiGetFeatureStateW(hinst, feature, installed, action);
2483 }
2484
2485 UINT __cdecl s_remote_SetFeatureState(MSIHANDLE hinst, LPCWSTR feature, INSTALLSTATE state)
2486 {
2487     return MsiSetFeatureStateW(hinst, feature, state);
2488 }
2489
2490 UINT __cdecl s_remote_GetComponentState(MSIHANDLE hinst, LPCWSTR component,
2491                                       INSTALLSTATE *installed, INSTALLSTATE *action)
2492 {
2493     return MsiGetComponentStateW(hinst, component, installed, action);
2494 }
2495
2496 UINT __cdecl s_remote_SetComponentState(MSIHANDLE hinst, LPCWSTR component, INSTALLSTATE state)
2497 {
2498     return MsiSetComponentStateW(hinst, component, state);
2499 }
2500
2501 LANGID __cdecl s_remote_GetLanguage(MSIHANDLE hinst)
2502 {
2503     return MsiGetLanguage(hinst);
2504 }
2505
2506 UINT __cdecl s_remote_SetInstallLevel(MSIHANDLE hinst, int level)
2507 {
2508     return MsiSetInstallLevel(hinst, level);
2509 }
2510
2511 UINT __cdecl s_remote_FormatRecord(MSIHANDLE hinst, struct wire_record *remote_rec, LPWSTR *value)
2512 {
2513     WCHAR empty[1];
2514     DWORD size = 0;
2515     MSIHANDLE rec;
2516     UINT r;
2517
2518     if ((r = unmarshal_record(remote_rec, &rec)))
2519         return r;
2520
2521     r = MsiFormatRecordW(hinst, rec, empty, &size);
2522     if (r == ERROR_MORE_DATA)
2523     {
2524         *value = midl_user_allocate(++size * sizeof(WCHAR));
2525         if (!*value)
2526         {
2527             MsiCloseHandle(rec);
2528             return ERROR_OUTOFMEMORY;
2529         }
2530         r = MsiFormatRecordW(hinst, rec, *value, &size);
2531     }
2532
2533     MsiCloseHandle(rec);
2534     return r;
2535 }
2536
2537 MSICONDITION __cdecl s_remote_EvaluateCondition(MSIHANDLE hinst, LPCWSTR condition)
2538 {
2539     return MsiEvaluateConditionW(hinst, condition);
2540 }
2541
2542 UINT __cdecl s_remote_GetFeatureCost(MSIHANDLE hinst, LPCWSTR feature,
2543     MSICOSTTREE cost_tree, INSTALLSTATE state, INT *cost)
2544 {
2545     return MsiGetFeatureCostW(hinst, feature, cost_tree, state, cost);
2546 }
2547
2548 UINT __cdecl s_remote_EnumComponentCosts(MSIHANDLE hinst, LPCWSTR component,
2549     DWORD index, INSTALLSTATE state, LPWSTR drive, INT *cost, INT *temp)
2550 {
2551     DWORD size = 3;
2552     return MsiEnumComponentCostsW(hinst, component, index, state, drive, &size, cost, temp);
2553 }
2554
2555 UINT msi_package_add_info(MSIPACKAGE *package, DWORD context, DWORD options,
2556                           LPCWSTR property, LPWSTR value)
2557 {
2558     MSISOURCELISTINFO *info;
2559
2560     LIST_FOR_EACH_ENTRY( info, &package->sourcelist_info, MSISOURCELISTINFO, entry )
2561     {
2562         if (!wcscmp( info->value, value )) return ERROR_SUCCESS;
2563     }
2564
2565     info = malloc(sizeof(MSISOURCELISTINFO));
2566     if (!info)
2567         return ERROR_OUTOFMEMORY;
2568
2569     info->context = context;
2570     info->options = options;
2571     info->property = property;
2572     info->value = wcsdup(value);
2573     list_add_head(&package->sourcelist_info, &info->entry);
2574
2575     return ERROR_SUCCESS;
2576 }
2577
2578 UINT msi_package_add_media_disk(MSIPACKAGE *package, DWORD context, DWORD options,
2579                                 DWORD disk_id, LPWSTR volume_label, LPWSTR disk_prompt)
2580 {
2581     MSIMEDIADISK *disk;
2582
2583     LIST_FOR_EACH_ENTRY( disk, &package->sourcelist_media, MSIMEDIADISK, entry )
2584     {
2585         if (disk->disk_id == disk_id) return ERROR_SUCCESS;
2586     }
2587
2588     disk = malloc(sizeof(MSIMEDIADISK));
2589     if (!disk)
2590         return ERROR_OUTOFMEMORY;
2591
2592     disk->context = context;
2593     disk->options = options;
2594     disk->disk_id = disk_id;
2595     disk->volume_label = wcsdup(volume_label);
2596     disk->disk_prompt = wcsdup(disk_prompt);
2597     list_add_head(&package->sourcelist_media, &disk->entry);
2598
2599     return ERROR_SUCCESS;
2600 }