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