dlls/msi/install.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2005 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 /* Msi top level apis directly related to installs */
  22
  23 #define COBJMACROS
  24
  25 #include <stdarg.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winerror.h"
  30 #include "msi.h"
  31 #include "msidefs.h"
  32 #include "objbase.h"
  33 #include "oleauto.h"
  34
  35 #include "msipriv.h"
  36 #include "winemsi.h"
  37 #include "wine/heap.h"
  38 #include "wine/debug.h"
  39 #include "wine/unicode.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  42
  43 /***********************************************************************
  44  * MsiDoActionA       (MSI.@)
  45  */
  46 UINT WINAPI MsiDoActionA( MSIHANDLE hInstall, LPCSTR szAction )
  47 {
  48     LPWSTR szwAction;
  49     UINT ret;
  50
  51     TRACE("%s\n", debugstr_a(szAction));
  52
  53     szwAction = strdupAtoW(szAction);
  54     if (szAction && !szwAction)
  55         return ERROR_FUNCTION_FAILED;
  56
  57     ret = MsiDoActionW( hInstall, szwAction );
  58     msi_free( szwAction );
  59     return ret;
  60 }
  61
  62 /***********************************************************************
  63  * MsiDoActionW       (MSI.@)
  64  */
  65 UINT WINAPI MsiDoActionW( MSIHANDLE hInstall, LPCWSTR szAction )
  66 {
  67     MSIPACKAGE *package;
  68     UINT ret;
  69
  70     TRACE("%s\n",debugstr_w(szAction));
  71
  72     if (!szAction)
  73         return ERROR_INVALID_PARAMETER;
  74
  75     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
  76     if (!package)
  77     {
  78         MSIHANDLE remote;
  79
  80         if (!(remote = msi_get_remote(hInstall)))
  81             return ERROR_INVALID_HANDLE;
  82
  83         return remote_DoAction(remote, szAction);
  84     }
  85
  86     ret = ACTION_PerformAction( package, szAction, SCRIPT_NONE );
  87     msiobj_release( &package->hdr );
  88
  89     return ret;
  90 }
  91
  92 /***********************************************************************
  93  * MsiSequenceA       (MSI.@)
  94  */
  95 UINT WINAPI MsiSequenceA( MSIHANDLE hInstall, LPCSTR szTable, INT iSequenceMode )
  96 {
  97     LPWSTR szwTable;
  98     UINT ret;
  99
 100     TRACE("%s, %d\n", debugstr_a(szTable), iSequenceMode);
 101
 102     szwTable = strdupAtoW(szTable);
 103     if (szTable && !szwTable)
 104         return ERROR_FUNCTION_FAILED;
 105
 106     ret = MsiSequenceW( hInstall, szwTable, iSequenceMode );
 107     msi_free( szwTable );
 108     return ret;
 109 }
 110
 111 /***********************************************************************
 112  * MsiSequenceW       (MSI.@)
 113  */
 114 UINT WINAPI MsiSequenceW( MSIHANDLE hInstall, LPCWSTR szTable, INT iSequenceMode )
 115 {
 116     MSIPACKAGE *package;
 117     UINT ret;
 118
 119     TRACE("%s, %d\n", debugstr_w(szTable), iSequenceMode);
 120
 121     if (!szTable)
 122         return ERROR_INVALID_PARAMETER;
 123
 124     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
 125     if (!package)
 126     {
 127         MSIHANDLE remote;
 128
 129         if (!(remote = msi_get_remote(hInstall)))
 130             return ERROR_INVALID_HANDLE;
 131
 132         return remote_Sequence(remote, szTable, iSequenceMode);
 133     }
 134     ret = MSI_Sequence( package, szTable );
 135     msiobj_release( &package->hdr );
 136     return ret;
 137 }
 138
 139 UINT msi_strcpy_to_awstring( const WCHAR *str, int len, awstring *awbuf, DWORD *sz )
 140 {
 141     UINT r = ERROR_SUCCESS;
 142
 143     if (awbuf->str.w && !sz)
 144         return ERROR_INVALID_PARAMETER;
 145     if (!sz)
 146         return ERROR_SUCCESS;
 147
 148     if (len < 0) len = strlenW( str );
 149
 150     if (awbuf->unicode && awbuf->str.w)
 151     {
 152         memcpy( awbuf->str.w, str, min(len + 1, *sz) * sizeof(WCHAR) );
 153         if (*sz && len >= *sz)
 154             awbuf->str.w[*sz - 1] = 0;
 155     }
 156     else
 157     {
 158         int lenA = WideCharToMultiByte( CP_ACP, 0, str, len + 1, NULL, 0, NULL, NULL );
 159         if (lenA) lenA--;
 160         WideCharToMultiByte( CP_ACP, 0, str, len + 1, awbuf->str.a, *sz, NULL, NULL );
 161         if (awbuf->str.a && *sz && lenA >= *sz)
 162             awbuf->str.a[*sz - 1] = 0;
 163         len = lenA;
 164     }
 165     if (awbuf->str.w && len >= *sz)
 166         r = ERROR_MORE_DATA;
 167     *sz = len;
 168     return r;
 169 }
 170
 171 const WCHAR *msi_get_target_folder( MSIPACKAGE *package, const WCHAR *name )
 172 {
 173     MSIFOLDER *folder = msi_get_loaded_folder( package, name );
 174
 175     if (!folder) return NULL;
 176     if (!folder->ResolvedTarget)
 177     {
 178         MSIFOLDER *parent = folder;
 179         while (parent->Parent && strcmpW( parent->Parent, parent->Directory ))
 180         {
 181             parent = msi_get_loaded_folder( package, parent->Parent );
 182         }
 183         msi_resolve_target_folder( package, parent->Directory, TRUE );
 184     }
 185     return folder->ResolvedTarget;
 186 }
 187
 188 /***********************************************************************
 189  * MsiGetTargetPath   (internal)
 190  */
 191 static UINT MSI_GetTargetPath( MSIHANDLE hInstall, LPCWSTR szFolder,
 192                                awstring *szPathBuf, LPDWORD pcchPathBuf )
 193 {
 194     MSIPACKAGE *package;
 195     const WCHAR *path;
 196     UINT r = ERROR_FUNCTION_FAILED;
 197
 198     if (!szFolder)
 199         return ERROR_INVALID_PARAMETER;
 200
 201     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
 202     if (!package)
 203     {
 204         LPWSTR value = NULL;
 205         MSIHANDLE remote;
 206
 207         if (!(remote = msi_get_remote(hInstall)))
 208             return ERROR_INVALID_HANDLE;
 209
 210         r = remote_GetTargetPath(remote, szFolder, &value);
 211         if (r != ERROR_SUCCESS)
 212             return r;
 213
 214         r = msi_strcpy_to_awstring(value, -1, szPathBuf, pcchPathBuf);
 215
 216         midl_user_free(value);
 217         return r;
 218     }
 219
 220     path = msi_get_target_folder( package, szFolder );
 221     msiobj_release( &package->hdr );
 222
 223     if (!path)
 224         return ERROR_DIRECTORY;
 225
 226     return msi_strcpy_to_awstring( path, -1, szPathBuf, pcchPathBuf );
 227 }
 228
 229 /***********************************************************************
 230  * MsiGetTargetPathA        (MSI.@)
 231  */
 232 UINT WINAPI MsiGetTargetPathA( MSIHANDLE hInstall, LPCSTR szFolder,
 233                                LPSTR szPathBuf, LPDWORD pcchPathBuf )
 234 {
 235     LPWSTR szwFolder;
 236     awstring path;
 237     UINT r;
 238
 239     TRACE("%s %p %p\n", debugstr_a(szFolder), szPathBuf, pcchPathBuf);
 240
 241     szwFolder = strdupAtoW(szFolder);
 242     if (szFolder && !szwFolder)
 243         return ERROR_FUNCTION_FAILED;
 244
 245     path.unicode = FALSE;
 246     path.str.a = szPathBuf;
 247
 248     r = MSI_GetTargetPath( hInstall, szwFolder, &path, pcchPathBuf );
 249
 250     msi_free( szwFolder );
 251
 252     return r;
 253 }
 254
 255 /***********************************************************************
 256  * MsiGetTargetPathW        (MSI.@)
 257  */
 258 UINT WINAPI MsiGetTargetPathW( MSIHANDLE hInstall, LPCWSTR szFolder,
 259                                LPWSTR szPathBuf, LPDWORD pcchPathBuf )
 260 {
 261     awstring path;
 262
 263     TRACE("%s %p %p\n", debugstr_w(szFolder), szPathBuf, pcchPathBuf);
 264
 265     path.unicode = TRUE;
 266     path.str.w = szPathBuf;
 267
 268     return MSI_GetTargetPath( hInstall, szFolder, &path, pcchPathBuf );
 269 }
 270
 271 static WCHAR *get_source_root( MSIPACKAGE *package )
 272 {
 273     msi_set_sourcedir_props( package, FALSE );
 274     return msi_dup_property( package->db, szSourceDir );
 275 }
 276
 277 WCHAR *msi_resolve_source_folder( MSIPACKAGE *package, const WCHAR *name, MSIFOLDER **folder )
 278 {
 279     MSIFOLDER *f;
 280     LPWSTR p, path = NULL, parent;
 281
 282     TRACE("working to resolve %s\n", debugstr_w(name));
 283
 284     if (!strcmpW( name, szSourceDir )) name = szTargetDir;
 285     if (!(f = msi_get_loaded_folder( package, name ))) return NULL;
 286
 287     /* special resolving for root dir */
 288     if (!strcmpW( name, szTargetDir ) && !f->ResolvedSource)
 289     {
 290         f->ResolvedSource = get_source_root( package );
 291     }
 292     if (folder) *folder = f;
 293     if (f->ResolvedSource)
 294     {
 295         path = strdupW( f->ResolvedSource );
 296         TRACE("   already resolved to %s\n", debugstr_w(path));
 297         return path;
 298     }
 299     if (!f->Parent) return path;
 300     parent = f->Parent;
 301     TRACE(" ! parent is %s\n", debugstr_w(parent));
 302
 303     p = msi_resolve_source_folder( package, parent, NULL );
 304
 305     if (package->WordCount & msidbSumInfoSourceTypeCompressed)
 306         path = get_source_root( package );
 307     else if (package->WordCount & msidbSumInfoSourceTypeSFN)
 308         path = msi_build_directory_name( 3, p, f->SourceShortPath, NULL );
 309     else
 310         path = msi_build_directory_name( 3, p, f->SourceLongPath, NULL );
 311
 312     TRACE("-> %s\n", debugstr_w(path));
 313     f->ResolvedSource = strdupW( path );
 314     msi_free( p );
 315
 316     return path;
 317 }
 318
 319 /***********************************************************************
 320  * MSI_GetSourcePath   (internal)
 321  */
 322 static UINT MSI_GetSourcePath( MSIHANDLE hInstall, LPCWSTR szFolder,
 323                                awstring *szPathBuf, LPDWORD pcchPathBuf )
 324 {
 325     MSIPACKAGE *package;
 326     LPWSTR path;
 327     UINT r = ERROR_FUNCTION_FAILED;
 328
 329     TRACE("%s %p %p\n", debugstr_w(szFolder), szPathBuf, pcchPathBuf );
 330
 331     if (!szFolder)
 332         return ERROR_INVALID_PARAMETER;
 333
 334     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
 335     if (!package)
 336     {
 337         LPWSTR value = NULL;
 338         MSIHANDLE remote;
 339
 340         if (!(remote = msi_get_remote(hInstall)))
 341             return ERROR_INVALID_HANDLE;
 342
 343         r = remote_GetSourcePath(remote, szFolder, &value);
 344         if (r != ERROR_SUCCESS)
 345             return r;
 346
 347         r = msi_strcpy_to_awstring(value, -1, szPathBuf, pcchPathBuf);
 348
 349         midl_user_free(value);
 350         return r;
 351     }
 352
 353     if (szPathBuf->str.w && !pcchPathBuf )
 354     {
 355         msiobj_release( &package->hdr );
 356         return ERROR_INVALID_PARAMETER;
 357     }
 358
 359     path = msi_resolve_source_folder( package, szFolder, NULL );
 360     msiobj_release( &package->hdr );
 361
 362     TRACE("path = %s\n", debugstr_w(path));
 363     if (!path)
 364         return ERROR_DIRECTORY;
 365
 366     r = msi_strcpy_to_awstring( path, -1, szPathBuf, pcchPathBuf );
 367     msi_free( path );
 368     return r;
 369 }
 370
 371 /***********************************************************************
 372  * MsiGetSourcePathA     (MSI.@)
 373  */
 374 UINT WINAPI MsiGetSourcePathA( MSIHANDLE hInstall, LPCSTR szFolder,
 375                                LPSTR szPathBuf, LPDWORD pcchPathBuf )
 376 {
 377     LPWSTR folder;
 378     awstring str;
 379     UINT r;
 380
 381     TRACE("%s %p %p\n", debugstr_a(szFolder), szPathBuf, pcchPathBuf);
 382
 383     str.unicode = FALSE;
 384     str.str.a = szPathBuf;
 385
 386     folder = strdupAtoW( szFolder );
 387     r = MSI_GetSourcePath( hInstall, folder, &str, pcchPathBuf );
 388     msi_free( folder );
 389
 390     return r;
 391 }
 392
 393 /***********************************************************************
 394  * MsiGetSourcePathW     (MSI.@)
 395  */
 396 UINT WINAPI MsiGetSourcePathW( MSIHANDLE hInstall, LPCWSTR szFolder,
 397                                LPWSTR szPathBuf, LPDWORD pcchPathBuf )
 398 {
 399     awstring str;
 400
 401     TRACE("%s %p %p\n", debugstr_w(szFolder), szPathBuf, pcchPathBuf );
 402
 403     str.unicode = TRUE;
 404     str.str.w = szPathBuf;
 405
 406     return MSI_GetSourcePath( hInstall, szFolder, &str, pcchPathBuf );
 407 }
 408
 409 /***********************************************************************
 410  * MsiSetTargetPathA  (MSI.@)
 411  */
 412 UINT WINAPI MsiSetTargetPathA( MSIHANDLE hInstall, LPCSTR szFolder,
 413                                LPCSTR szFolderPath )
 414 {
 415     LPWSTR szwFolder = NULL, szwFolderPath = NULL;
 416     UINT rc = ERROR_OUTOFMEMORY;
 417
 418     if ( !szFolder || !szFolderPath )
 419         return ERROR_INVALID_PARAMETER;
 420
 421     szwFolder = strdupAtoW(szFolder);
 422     szwFolderPath = strdupAtoW(szFolderPath);
 423     if (!szwFolder || !szwFolderPath)
 424         goto end;
 425
 426     rc = MsiSetTargetPathW( hInstall, szwFolder, szwFolderPath );
 427
 428 end:
 429     msi_free(szwFolder);
 430     msi_free(szwFolderPath);
 431
 432     return rc;
 433 }
 434
 435 static void set_target_path( MSIPACKAGE *package, MSIFOLDER *folder, const WCHAR *path )
 436 {
 437     FolderList *fl;
 438     MSIFOLDER *child;
 439     WCHAR *target_path;
 440
 441     if (!(target_path = msi_normalize_path( path ))) return;
 442     if (strcmpW( target_path, folder->ResolvedTarget ))
 443     {
 444         msi_free( folder->ResolvedTarget );
 445         folder->ResolvedTarget = target_path;
 446         msi_set_property( package->db, folder->Directory, folder->ResolvedTarget, -1 );
 447
 448         LIST_FOR_EACH_ENTRY( fl, &folder->children, FolderList, entry )
 449         {
 450             child = fl->folder;
 451             msi_resolve_target_folder( package, child->Directory, FALSE );
 452         }
 453     }
 454     else msi_free( target_path );
 455 }
 456
 457 UINT MSI_SetTargetPathW( MSIPACKAGE *package, LPCWSTR szFolder, LPCWSTR szFolderPath )
 458 {
 459     DWORD attrib;
 460     MSIFOLDER *folder;
 461     MSIFILE *file;
 462
 463     TRACE("%p %s %s\n", package, debugstr_w(szFolder), debugstr_w(szFolderPath));
 464
 465     attrib = GetFileAttributesW(szFolderPath);
 466     /* native MSI tests writeability by making temporary files at each drive */
 467     if (attrib != INVALID_FILE_ATTRIBUTES &&
 468         (attrib & FILE_ATTRIBUTE_OFFLINE || attrib & FILE_ATTRIBUTE_READONLY))
 469     {
 470         return ERROR_FUNCTION_FAILED;
 471     }
 472     if (!(folder = msi_get_loaded_folder( package, szFolder ))) return ERROR_DIRECTORY;
 473
 474     set_target_path( package, folder, szFolderPath );
 475
 476     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
 477     {
 478         const WCHAR *dir;
 479         MSICOMPONENT *comp = file->Component;
 480
 481         if (!comp->Enabled || msi_is_global_assembly( comp )) continue;
 482
 483         dir = msi_get_target_folder( package, comp->Directory );
 484         msi_free( file->TargetPath );
 485         file->TargetPath = msi_build_directory_name( 2, dir, file->FileName );
 486     }
 487     return ERROR_SUCCESS;
 488 }
 489
 490 /***********************************************************************
 491  * MsiSetTargetPathW  (MSI.@)
 492  */
 493 UINT WINAPI MsiSetTargetPathW(MSIHANDLE hInstall, LPCWSTR szFolder,
 494                              LPCWSTR szFolderPath)
 495 {
 496     MSIPACKAGE *package;
 497     UINT ret;
 498
 499     TRACE("%s %s\n",debugstr_w(szFolder),debugstr_w(szFolderPath));
 500
 501     if ( !szFolder || !szFolderPath )
 502         return ERROR_INVALID_PARAMETER;
 503
 504     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 505     if (!package)
 506     {
 507         MSIHANDLE remote;
 508
 509         if (!(remote = msi_get_remote(hInstall)))
 510             return ERROR_INVALID_HANDLE;
 511
 512         return remote_SetTargetPath(remote, szFolder, szFolderPath);
 513     }
 514
 515     ret = MSI_SetTargetPathW( package, szFolder, szFolderPath );
 516     msiobj_release( &package->hdr );
 517     return ret;
 518 }
 519
 520 /***********************************************************************
 521  *           MsiGetMode    (MSI.@)
 522  *
 523  * Returns an internal installer state (if it is running in a mode iRunMode)
 524  *
 525  * PARAMS
 526  *   hInstall    [I]  Handle to the installation
 527  *   hRunMode    [I]  Checking run mode
 528  *        MSIRUNMODE_ADMIN             Administrative mode
 529  *        MSIRUNMODE_ADVERTISE         Advertisement mode
 530  *        MSIRUNMODE_MAINTENANCE       Maintenance mode
 531  *        MSIRUNMODE_ROLLBACKENABLED   Rollback is enabled
 532  *        MSIRUNMODE_LOGENABLED        Log file is writing
 533  *        MSIRUNMODE_OPERATIONS        Operations in progress??
 534  *        MSIRUNMODE_REBOOTATEND       We need to reboot after installation completed
 535  *        MSIRUNMODE_REBOOTNOW         We need to reboot to continue the installation
 536  *        MSIRUNMODE_CABINET           Files from cabinet are installed
 537  *        MSIRUNMODE_SOURCESHORTNAMES  Long names in source files is suppressed
 538  *        MSIRUNMODE_TARGETSHORTNAMES  Long names in destination files is suppressed
 539  *        MSIRUNMODE_RESERVED11        Reserved
 540  *        MSIRUNMODE_WINDOWS9X         Running under Windows95/98
 541  *        MSIRUNMODE_ZAWENABLED        Demand installation is supported
 542  *        MSIRUNMODE_RESERVED14        Reserved
 543  *        MSIRUNMODE_RESERVED15        Reserved
 544  *        MSIRUNMODE_SCHEDULED         called from install script
 545  *        MSIRUNMODE_ROLLBACK          called from rollback script
 546  *        MSIRUNMODE_COMMIT            called from commit script
 547  *
 548  * RETURNS
 549  *    In the state: TRUE
 550  *    Not in the state: FALSE
 551  *
 552  */
 553 BOOL WINAPI MsiGetMode(MSIHANDLE hInstall, MSIRUNMODE iRunMode)
 554 {
 555     MSIPACKAGE *package;
 556     BOOL r = FALSE;
 557
 558     TRACE("%d %d\n", hInstall, iRunMode);
 559
 560     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 561     if (!package)
 562     {
 563         MSIHANDLE remote;
 564         BOOL ret;
 565         HRESULT hr;
 566
 567         if (!(remote = msi_get_remote(hInstall)))
 568             return FALSE;
 569
 570         hr = remote_GetMode(remote, iRunMode, &ret);
 571
 572         if (hr == S_OK)
 573             return ret;
 574
 575         return FALSE;
 576     }
 577
 578     switch (iRunMode)
 579     {
 580     case MSIRUNMODE_ADMIN:
 581         FIXME("no support for administrative installs\n");
 582         break;
 583
 584     case MSIRUNMODE_ADVERTISE:
 585         FIXME("no support for advertised installs\n");
 586         break;
 587
 588     case MSIRUNMODE_WINDOWS9X:
 589         if (GetVersion() & 0x80000000)
 590             r = TRUE;
 591         break;
 592
 593     case MSIRUNMODE_OPERATIONS:
 594     case MSIRUNMODE_RESERVED11:
 595     case MSIRUNMODE_RESERVED14:
 596     case MSIRUNMODE_RESERVED15:
 597         break;
 598
 599     case MSIRUNMODE_SCHEDULED:
 600         r = package->scheduled_action_running;
 601         break;
 602
 603     case MSIRUNMODE_ROLLBACK:
 604         r = package->rollback_action_running;
 605         break;
 606
 607     case MSIRUNMODE_COMMIT:
 608         r = package->commit_action_running;
 609         break;
 610
 611     case MSIRUNMODE_MAINTENANCE:
 612         r = msi_get_property_int( package->db, szInstalled, 0 ) != 0;
 613         break;
 614
 615     case MSIRUNMODE_ROLLBACKENABLED:
 616         r = msi_get_property_int( package->db, szRollbackDisabled, 0 ) == 0;
 617         break;
 618
 619     case MSIRUNMODE_REBOOTATEND:
 620         r = package->need_reboot_at_end;
 621         break;
 622
 623     case MSIRUNMODE_REBOOTNOW:
 624         r = package->need_reboot_now;
 625         break;
 626
 627     case MSIRUNMODE_LOGENABLED:
 628         r = (package->log_file != INVALID_HANDLE_VALUE);
 629         break;
 630
 631     default:
 632         FIXME("unimplemented run mode: %d\n", iRunMode);
 633         r = TRUE;
 634     }
 635
 636     msiobj_release( &package->hdr );
 637     return r;
 638 }
 639
 640 /***********************************************************************
 641  *           MsiSetMode    (MSI.@)
 642  */
 643 UINT WINAPI MsiSetMode(MSIHANDLE hInstall, MSIRUNMODE iRunMode, BOOL fState)
 644 {
 645     MSIPACKAGE *package;
 646     UINT r;
 647
 648     TRACE("%d %d %d\n", hInstall, iRunMode, fState);
 649
 650     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
 651     if (!package)
 652     {
 653         MSIHANDLE remote;
 654         HRESULT hr;
 655
 656         if (!(remote = msi_get_remote(hInstall)))
 657             return FALSE;
 658
 659         hr = remote_SetMode(remote, iRunMode, fState);
 660
 661         if (FAILED(hr))
 662         {
 663             if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
 664                 return HRESULT_CODE(hr);
 665
 666             return ERROR_FUNCTION_FAILED;
 667         }
 668
 669         return ERROR_SUCCESS;
 670     }
 671
 672     switch (iRunMode)
 673     {
 674     case MSIRUNMODE_REBOOTATEND:
 675         package->need_reboot_at_end = (fState != 0);
 676         r = ERROR_SUCCESS;
 677         break;
 678
 679     case MSIRUNMODE_REBOOTNOW:
 680         package->need_reboot_now = (fState != 0);
 681         r = ERROR_SUCCESS;
 682         break;
 683
 684     default:
 685         r = ERROR_ACCESS_DENIED;
 686     }
 687
 688     msiobj_release( &package->hdr );
 689     return r;
 690 }
 691
 692 /***********************************************************************
 693  * MsiSetFeatureStateA (MSI.@)
 694  *
 695  * According to the docs, when this is called it immediately recalculates
 696  * all the component states as well
 697  */
 698 UINT WINAPI MsiSetFeatureStateA(MSIHANDLE hInstall, LPCSTR szFeature,
 699                                 INSTALLSTATE iState)
 700 {
 701     LPWSTR szwFeature = NULL;
 702     UINT rc;
 703
 704     szwFeature = strdupAtoW(szFeature);
 705
 706     if (!szwFeature)
 707         return ERROR_FUNCTION_FAILED;
 708
 709     rc = MsiSetFeatureStateW(hInstall,szwFeature, iState);
 710
 711     msi_free(szwFeature);
 712
 713     return rc;
 714 }
 715
 716 /* update component state based on a feature change */
 717 void ACTION_UpdateComponentStates( MSIPACKAGE *package, MSIFEATURE *feature )
 718 {
 719     INSTALLSTATE newstate;
 720     ComponentList *cl;
 721
 722     newstate = feature->ActionRequest;
 723     if (newstate == INSTALLSTATE_ABSENT) newstate = INSTALLSTATE_UNKNOWN;
 724
 725     LIST_FOR_EACH_ENTRY(cl, &feature->Components, ComponentList, entry)
 726     {
 727         MSICOMPONENT *component = cl->component;
 728
 729         if (!component->Enabled) continue;
 730
 731         TRACE("Modifying (%d): Component %s (Installed %d, Action %d, Request %d)\n",
 732             newstate, debugstr_w(component->Component), component->Installed,
 733             component->Action, component->ActionRequest);
 734
 735         if (newstate == INSTALLSTATE_LOCAL)
 736         {
 737             component->Action = INSTALLSTATE_LOCAL;
 738             component->ActionRequest = INSTALLSTATE_LOCAL;
 739         }
 740         else
 741         {
 742             ComponentList *clist;
 743             MSIFEATURE *f;
 744
 745             component->hasLocalFeature = FALSE;
 746
 747             component->Action = newstate;
 748             component->ActionRequest = newstate;
 749             /* if any other feature wants it local we need to set it local */
 750             LIST_FOR_EACH_ENTRY(f, &package->features, MSIFEATURE, entry)
 751             {
 752                 if ( f->ActionRequest != INSTALLSTATE_LOCAL &&
 753                      f->ActionRequest != INSTALLSTATE_SOURCE )
 754                 {
 755                     continue;
 756                 }
 757                 LIST_FOR_EACH_ENTRY(clist, &f->Components, ComponentList, entry)
 758                 {
 759                     if (clist->component == component &&
 760                         (f->ActionRequest == INSTALLSTATE_LOCAL ||
 761                          f->ActionRequest == INSTALLSTATE_SOURCE))
 762                     {
 763                         TRACE("Saved by %s\n", debugstr_w(f->Feature));
 764                         component->hasLocalFeature = TRUE;
 765
 766                         if (component->Attributes & msidbComponentAttributesOptional)
 767                         {
 768                             if (f->Attributes & msidbFeatureAttributesFavorSource)
 769                             {
 770                                 component->Action = INSTALLSTATE_SOURCE;
 771                                 component->ActionRequest = INSTALLSTATE_SOURCE;
 772                             }
 773                             else
 774                             {
 775                                 component->Action = INSTALLSTATE_LOCAL;
 776                                 component->ActionRequest = INSTALLSTATE_LOCAL;
 777                             }
 778                         }
 779                         else if (component->Attributes & msidbComponentAttributesSourceOnly)
 780                         {
 781                             component->Action = INSTALLSTATE_SOURCE;
 782                             component->ActionRequest = INSTALLSTATE_SOURCE;
 783                         }
 784                         else
 785                         {
 786                             component->Action = INSTALLSTATE_LOCAL;
 787                             component->ActionRequest = INSTALLSTATE_LOCAL;
 788                         }
 789                     }
 790                 }
 791             }
 792         }
 793         TRACE("Result (%d): Component %s (Installed %d, Action %d, Request %d)\n",
 794             newstate, debugstr_w(component->Component), component->Installed,
 795             component->Action, component->ActionRequest);
 796     }
 797 }
 798
 799 UINT MSI_SetFeatureStateW( MSIPACKAGE *package, LPCWSTR szFeature, INSTALLSTATE iState )
 800 {
 801     UINT rc = ERROR_SUCCESS;
 802     MSIFEATURE *feature, *child;
 803
 804     TRACE("%s %i\n", debugstr_w(szFeature), iState);
 805
 806     feature = msi_get_loaded_feature( package, szFeature );
 807     if (!feature)
 808         return ERROR_UNKNOWN_FEATURE;
 809
 810     if (iState == INSTALLSTATE_ADVERTISED &&
 811         feature->Attributes & msidbFeatureAttributesDisallowAdvertise)
 812         return ERROR_FUNCTION_FAILED;
 813
 814     feature->ActionRequest = iState;
 815
 816     ACTION_UpdateComponentStates( package, feature );
 817
 818     /* update all the features that are children of this feature */
 819     LIST_FOR_EACH_ENTRY( child, &package->features, MSIFEATURE, entry )
 820     {
 821         if (child->Feature_Parent && !strcmpW( szFeature, child->Feature_Parent ))
 822             MSI_SetFeatureStateW(package, child->Feature, iState);
 823     }
 824
 825     return rc;
 826 }
 827
 828 /***********************************************************************
 829  * MsiSetFeatureStateW (MSI.@)
 830  */
 831 UINT WINAPI MsiSetFeatureStateW(MSIHANDLE hInstall, LPCWSTR szFeature,
 832                                 INSTALLSTATE iState)
 833 {
 834     MSIPACKAGE* package;
 835     UINT rc = ERROR_SUCCESS;
 836
 837     TRACE("%s %i\n",debugstr_w(szFeature), iState);
 838
 839     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 840     if (!package)
 841     {
 842         MSIHANDLE remote;
 843         HRESULT hr;
 844         BSTR feature;
 845
 846         if (!(remote = msi_get_remote(hInstall)))
 847             return ERROR_INVALID_HANDLE;
 848
 849         feature = SysAllocString(szFeature);
 850         if (!feature)
 851             return ERROR_OUTOFMEMORY;
 852
 853         hr = remote_SetFeatureState(remote, feature, iState);
 854
 855         SysFreeString(feature);
 856
 857         if (FAILED(hr))
 858         {
 859             if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
 860                 return HRESULT_CODE(hr);
 861
 862             return ERROR_FUNCTION_FAILED;
 863         }
 864
 865         return ERROR_SUCCESS;
 866     }
 867
 868     rc = MSI_SetFeatureStateW(package,szFeature,iState);
 869
 870     msiobj_release( &package->hdr );
 871     return rc;
 872 }
 873
 874 /***********************************************************************
 875 * MsiSetFeatureAttributesA   (MSI.@)
 876 */
 877 UINT WINAPI MsiSetFeatureAttributesA( MSIHANDLE handle, LPCSTR feature, DWORD attrs )
 878 {
 879     UINT r;
 880     WCHAR *featureW = NULL;
 881
 882     TRACE("%u, %s, 0x%08x\n", handle, debugstr_a(feature), attrs);
 883
 884     if (feature && !(featureW = strdupAtoW( feature ))) return ERROR_OUTOFMEMORY;
 885
 886     r = MsiSetFeatureAttributesW( handle, featureW, attrs );
 887     msi_free( featureW );
 888     return r;
 889 }
 890
 891 static DWORD unmap_feature_attributes( DWORD attrs )
 892 {
 893     DWORD ret = 0;
 894
 895     if (attrs & INSTALLFEATUREATTRIBUTE_FAVORLOCAL)             ret = msidbFeatureAttributesFavorLocal;
 896     if (attrs & INSTALLFEATUREATTRIBUTE_FAVORSOURCE)            ret |= msidbFeatureAttributesFavorSource;
 897     if (attrs & INSTALLFEATUREATTRIBUTE_FOLLOWPARENT)           ret |= msidbFeatureAttributesFollowParent;
 898     if (attrs & INSTALLFEATUREATTRIBUTE_FAVORADVERTISE)         ret |= msidbFeatureAttributesFavorAdvertise;
 899     if (attrs & INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE)      ret |= msidbFeatureAttributesDisallowAdvertise;
 900     if (attrs & INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE) ret |= msidbFeatureAttributesNoUnsupportedAdvertise;
 901     return ret;
 902 }
 903
 904 /***********************************************************************
 905 * MsiSetFeatureAttributesW   (MSI.@)
 906 */
 907 UINT WINAPI MsiSetFeatureAttributesW( MSIHANDLE handle, LPCWSTR name, DWORD attrs )
 908 {
 909     MSIPACKAGE *package;
 910     MSIFEATURE *feature;
 911     WCHAR *costing;
 912
 913     TRACE("%u, %s, 0x%08x\n", handle, debugstr_w(name), attrs);
 914
 915     if (!name || !name[0]) return ERROR_UNKNOWN_FEATURE;
 916
 917     if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE )))
 918         return ERROR_INVALID_HANDLE;
 919
 920     costing = msi_dup_property( package->db, szCostingComplete );
 921     if (!costing || !strcmpW( costing, szOne ))
 922     {
 923         msi_free( costing );
 924         msiobj_release( &package->hdr );
 925         return ERROR_FUNCTION_FAILED;
 926     }
 927     msi_free( costing );
 928     if (!(feature = msi_get_loaded_feature( package, name )))
 929     {
 930         msiobj_release( &package->hdr );
 931         return ERROR_UNKNOWN_FEATURE;
 932     }
 933     feature->Attributes = unmap_feature_attributes( attrs );
 934     msiobj_release( &package->hdr );
 935     return ERROR_SUCCESS;
 936 }
 937
 938 /***********************************************************************
 939 * MsiGetFeatureStateA   (MSI.@)
 940 */
 941 UINT WINAPI MsiGetFeatureStateA(MSIHANDLE hInstall, LPCSTR szFeature,
 942                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
 943 {
 944     LPWSTR szwFeature = NULL;
 945     UINT rc;
 946
 947     if (szFeature && !(szwFeature = strdupAtoW(szFeature))) return ERROR_OUTOFMEMORY;
 948
 949     rc = MsiGetFeatureStateW(hInstall, szwFeature, piInstalled, piAction);
 950     msi_free( szwFeature);
 951     return rc;
 952 }
 953
 954 UINT MSI_GetFeatureStateW(MSIPACKAGE *package, LPCWSTR szFeature,
 955                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
 956 {
 957     MSIFEATURE *feature;
 958
 959     feature = msi_get_loaded_feature(package,szFeature);
 960     if (!feature)
 961         return ERROR_UNKNOWN_FEATURE;
 962
 963     if (piInstalled)
 964         *piInstalled = feature->Installed;
 965
 966     if (piAction)
 967         *piAction = feature->ActionRequest;
 968
 969     TRACE("returning %i %i\n", feature->Installed, feature->ActionRequest);
 970
 971     return ERROR_SUCCESS;
 972 }
 973
 974 /***********************************************************************
 975 * MsiGetFeatureStateW   (MSI.@)
 976 */
 977 UINT WINAPI MsiGetFeatureStateW(MSIHANDLE hInstall, LPCWSTR szFeature,
 978                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
 979 {
 980     MSIPACKAGE* package;
 981     UINT ret;
 982
 983     TRACE("%d %s %p %p\n", hInstall, debugstr_w(szFeature), piInstalled, piAction);
 984
 985     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 986     if (!package)
 987     {
 988         MSIHANDLE remote;
 989         HRESULT hr;
 990         BSTR feature;
 991
 992         if (!(remote = msi_get_remote(hInstall)))
 993             return ERROR_INVALID_HANDLE;
 994
 995         feature = SysAllocString(szFeature);
 996         if (!feature)
 997             return ERROR_OUTOFMEMORY;
 998
 999         hr = remote_GetFeatureState(remote, feature, piInstalled, piAction);
1000
1001         SysFreeString(feature);
1002
1003         if (FAILED(hr))
1004         {
1005             if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
1006                 return HRESULT_CODE(hr);
1007
1008             return ERROR_FUNCTION_FAILED;
1009         }
1010
1011         return ERROR_SUCCESS;
1012     }
1013
1014     ret = MSI_GetFeatureStateW(package, szFeature, piInstalled, piAction);
1015     msiobj_release( &package->hdr );
1016     return ret;
1017 }
1018
1019 /***********************************************************************
1020 * MsiGetFeatureCostA   (MSI.@)
1021 */
1022 UINT WINAPI MsiGetFeatureCostA(MSIHANDLE hInstall, LPCSTR szFeature,
1023                   MSICOSTTREE iCostTree, INSTALLSTATE iState, LPINT piCost)
1024 {
1025     LPWSTR szwFeature = NULL;
1026     UINT rc;
1027
1028     szwFeature = strdupAtoW(szFeature);
1029
1030     rc = MsiGetFeatureCostW(hInstall, szwFeature, iCostTree, iState, piCost);
1031
1032     msi_free(szwFeature);
1033
1034     return rc;
1035 }
1036
1037 static INT feature_cost( MSIFEATURE *feature )
1038 {
1039     INT cost = 0;
1040     ComponentList *cl;
1041
1042     LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1043     {
1044         cost += cl->component->Cost;
1045     }
1046     return cost;
1047 }
1048
1049 UINT MSI_GetFeatureCost( MSIPACKAGE *package, MSIFEATURE *feature, MSICOSTTREE tree,
1050                          INSTALLSTATE state, LPINT cost )
1051 {
1052     TRACE("%s, %u, %d, %p\n", debugstr_w(feature->Feature), tree, state, cost);
1053
1054     *cost = 0;
1055     switch (tree)
1056     {
1057     case MSICOSTTREE_CHILDREN:
1058     {
1059         MSIFEATURE *child;
1060
1061         LIST_FOR_EACH_ENTRY( child, &feature->Children, MSIFEATURE, entry )
1062         {
1063             if (child->ActionRequest == state)
1064                 *cost += feature_cost( child );
1065         }
1066         break;
1067     }
1068     case MSICOSTTREE_PARENTS:
1069     {
1070         const WCHAR *feature_parent = feature->Feature_Parent;
1071         for (;;)
1072         {
1073             MSIFEATURE *parent = msi_get_loaded_feature( package, feature_parent );
1074             if (!parent)
1075                 break;
1076
1077             if (parent->ActionRequest == state)
1078                 *cost += feature_cost( parent );
1079
1080             feature_parent = parent->Feature_Parent;
1081         }
1082         break;
1083     }
1084     case MSICOSTTREE_SELFONLY:
1085         if (feature->ActionRequest == state)
1086             *cost = feature_cost( feature );
1087         break;
1088
1089     default:
1090         WARN("unhandled cost tree %u\n", tree);
1091         break;
1092     }
1093
1094     *cost /= 512;
1095     return ERROR_SUCCESS;
1096 }
1097
1098 /***********************************************************************
1099 * MsiGetFeatureCostW   (MSI.@)
1100 */
1101 UINT WINAPI MsiGetFeatureCostW(MSIHANDLE hInstall, LPCWSTR szFeature,
1102                   MSICOSTTREE iCostTree, INSTALLSTATE iState, LPINT piCost)
1103 {
1104     MSIPACKAGE *package;
1105     MSIFEATURE *feature;
1106     UINT ret;
1107
1108     TRACE("(%d %s %i %i %p)\n", hInstall, debugstr_w(szFeature),
1109           iCostTree, iState, piCost);
1110
1111     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1112     if (!package)
1113     {
1114         MSIHANDLE remote;
1115         HRESULT hr;
1116         BSTR feature;
1117
1118         if (!(remote = msi_get_remote(hInstall)))
1119             return ERROR_INVALID_HANDLE;
1120
1121         feature = SysAllocString(szFeature);
1122         if (!feature)
1123             return ERROR_OUTOFMEMORY;
1124
1125         hr = remote_GetFeatureCost(remote, feature, iCostTree, iState, piCost);
1126
1127         SysFreeString(feature);
1128
1129         if (FAILED(hr))
1130         {
1131             if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
1132                 return HRESULT_CODE(hr);
1133
1134             return ERROR_FUNCTION_FAILED;
1135         }
1136
1137         return ERROR_SUCCESS;
1138     }
1139
1140     feature = msi_get_loaded_feature(package, szFeature);
1141
1142     if (feature)
1143         ret = MSI_GetFeatureCost(package, feature, iCostTree, iState, piCost);
1144     else
1145         ret = ERROR_UNKNOWN_FEATURE;
1146
1147     msiobj_release( &package->hdr );
1148     return ret;
1149 }
1150
1151 /***********************************************************************
1152 * MsiGetFeatureInfoA   (MSI.@)
1153 */
1154 UINT WINAPI MsiGetFeatureInfoA( MSIHANDLE handle, LPCSTR feature, LPDWORD attrs,
1155                                 LPSTR title, LPDWORD title_len, LPSTR help, LPDWORD help_len )
1156 {
1157     UINT r;
1158     WCHAR *titleW = NULL, *helpW = NULL, *featureW = NULL;
1159
1160     TRACE("%u, %s, %p, %p, %p, %p, %p\n", handle, debugstr_a(feature), attrs, title,
1161           title_len, help, help_len);
1162
1163     if (feature && !(featureW = strdupAtoW( feature ))) return ERROR_OUTOFMEMORY;
1164
1165     if (title && title_len && !(titleW = msi_alloc( *title_len * sizeof(WCHAR) )))
1166     {
1167         msi_free( featureW );
1168         return ERROR_OUTOFMEMORY;
1169     }
1170     if (help && help_len && !(helpW = msi_alloc( *help_len * sizeof(WCHAR) )))
1171     {
1172         msi_free( featureW );
1173         msi_free( titleW );
1174         return ERROR_OUTOFMEMORY;
1175     }
1176     r = MsiGetFeatureInfoW( handle, featureW, attrs, titleW, title_len, helpW, help_len );
1177     if (r == ERROR_SUCCESS)
1178     {
1179         if (titleW) WideCharToMultiByte( CP_ACP, 0, titleW, -1, title, *title_len + 1, NULL, NULL );
1180         if (helpW) WideCharToMultiByte( CP_ACP, 0, helpW, -1, help, *help_len + 1, NULL, NULL );
1181     }
1182     msi_free( titleW );
1183     msi_free( helpW );
1184     msi_free( featureW );
1185     return r;
1186 }
1187
1188 static DWORD map_feature_attributes( DWORD attrs )
1189 {
1190     DWORD ret = 0;
1191
1192     if (attrs == msidbFeatureAttributesFavorLocal)            ret |= INSTALLFEATUREATTRIBUTE_FAVORLOCAL;
1193     if (attrs & msidbFeatureAttributesFavorSource)            ret |= INSTALLFEATUREATTRIBUTE_FAVORSOURCE;
1194     if (attrs & msidbFeatureAttributesFollowParent)           ret |= INSTALLFEATUREATTRIBUTE_FOLLOWPARENT;
1195     if (attrs & msidbFeatureAttributesFavorAdvertise)         ret |= INSTALLFEATUREATTRIBUTE_FAVORADVERTISE;
1196     if (attrs & msidbFeatureAttributesDisallowAdvertise)      ret |= INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE;
1197     if (attrs & msidbFeatureAttributesNoUnsupportedAdvertise) ret |= INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE;
1198     return ret;
1199 }
1200
1201 static UINT MSI_GetFeatureInfo( MSIPACKAGE *package, LPCWSTR name, LPDWORD attrs,
1202                                 LPWSTR title, LPDWORD title_len, LPWSTR help, LPDWORD help_len )
1203 {
1204     UINT r = ERROR_SUCCESS;
1205     MSIFEATURE *feature = msi_get_loaded_feature( package, name );
1206     int len;
1207
1208     if (!feature) return ERROR_UNKNOWN_FEATURE;
1209     if (attrs) *attrs = map_feature_attributes( feature->Attributes );
1210     if (title_len)
1211     {
1212         if (feature->Title) len = strlenW( feature->Title );
1213         else len = 0;
1214         if (*title_len <= len)
1215         {
1216             *title_len = len;
1217             if (title) r = ERROR_MORE_DATA;
1218         }
1219         else if (title)
1220         {
1221             if (feature->Title) strcpyW( title, feature->Title );
1222             else *title = 0;
1223             *title_len = len;
1224         }
1225     }
1226     if (help_len)
1227     {
1228         if (feature->Description) len = strlenW( feature->Description );
1229         else len = 0;
1230         if (*help_len <= len)
1231         {
1232             *help_len = len;
1233             if (help) r = ERROR_MORE_DATA;
1234         }
1235         else if (help)
1236         {
1237             if (feature->Description) strcpyW( help, feature->Description );
1238             else *help = 0;
1239             *help_len = len;
1240         }
1241     }
1242     return r;
1243 }
1244
1245 /***********************************************************************
1246 * MsiGetFeatureInfoW   (MSI.@)
1247 */
1248 UINT WINAPI MsiGetFeatureInfoW( MSIHANDLE handle, LPCWSTR feature, LPDWORD attrs,
1249                                 LPWSTR title, LPDWORD title_len, LPWSTR help, LPDWORD help_len )
1250 {
1251     UINT r;
1252     MSIPACKAGE *package;
1253
1254     TRACE("%u, %s, %p, %p, %p, %p, %p\n", handle, debugstr_w(feature), attrs, title,
1255           title_len, help, help_len);
1256
1257     if (!feature) return ERROR_INVALID_PARAMETER;
1258
1259     if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE )))
1260         return ERROR_INVALID_HANDLE;
1261
1262     /* features may not have been loaded yet */
1263     msi_load_all_components( package );
1264     msi_load_all_features( package );
1265
1266     r = MSI_GetFeatureInfo( package, feature, attrs, title, title_len, help, help_len );
1267     msiobj_release( &package->hdr );
1268     return r;
1269 }
1270
1271 /***********************************************************************
1272  * MsiSetComponentStateA (MSI.@)
1273  */
1274 UINT WINAPI MsiSetComponentStateA(MSIHANDLE hInstall, LPCSTR szComponent,
1275                                   INSTALLSTATE iState)
1276 {
1277     UINT rc;
1278     LPWSTR szwComponent = strdupAtoW(szComponent);
1279
1280     rc = MsiSetComponentStateW(hInstall, szwComponent, iState);
1281
1282     msi_free(szwComponent);
1283
1284     return rc;
1285 }
1286
1287 /***********************************************************************
1288  * MsiGetComponentStateA (MSI.@)
1289  */
1290 UINT WINAPI MsiGetComponentStateA(MSIHANDLE hInstall, LPCSTR szComponent,
1291                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
1292 {
1293     LPWSTR szwComponent= NULL;
1294     UINT rc;
1295
1296     szwComponent= strdupAtoW(szComponent);
1297
1298     rc = MsiGetComponentStateW(hInstall,szwComponent,piInstalled, piAction);
1299
1300     msi_free( szwComponent);
1301
1302     return rc;
1303 }
1304
1305 static UINT MSI_SetComponentStateW(MSIPACKAGE *package, LPCWSTR szComponent,
1306                                    INSTALLSTATE iState)
1307 {
1308     MSICOMPONENT *comp;
1309
1310     TRACE("%p %s %d\n", package, debugstr_w(szComponent), iState);
1311
1312     comp = msi_get_loaded_component(package, szComponent);
1313     if (!comp)
1314         return ERROR_UNKNOWN_COMPONENT;
1315
1316     if (comp->Enabled)
1317         comp->Action = iState;
1318
1319     return ERROR_SUCCESS;
1320 }
1321
1322 UINT MSI_GetComponentStateW(MSIPACKAGE *package, LPCWSTR szComponent,
1323                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
1324 {
1325     MSICOMPONENT *comp;
1326
1327     TRACE("%p %s %p %p\n", package, debugstr_w(szComponent),
1328            piInstalled, piAction);
1329
1330     comp = msi_get_loaded_component(package,szComponent);
1331     if (!comp)
1332         return ERROR_UNKNOWN_COMPONENT;
1333
1334     if (piInstalled)
1335     {
1336         if (comp->Enabled)
1337             *piInstalled = comp->Installed;
1338         else
1339             *piInstalled = INSTALLSTATE_UNKNOWN;
1340     }
1341
1342     if (piAction)
1343     {
1344         if (comp->Enabled)
1345             *piAction = comp->Action;
1346         else
1347             *piAction = INSTALLSTATE_UNKNOWN;
1348     }
1349
1350     TRACE("states (%i, %i)\n", comp->Installed, comp->Action );
1351     return ERROR_SUCCESS;
1352 }
1353
1354 /***********************************************************************
1355  * MsiSetComponentStateW (MSI.@)
1356  */
1357 UINT WINAPI MsiSetComponentStateW(MSIHANDLE hInstall, LPCWSTR szComponent,
1358                                   INSTALLSTATE iState)
1359 {
1360     MSIPACKAGE* package;
1361     UINT ret;
1362
1363     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1364     if (!package)
1365     {
1366         MSIHANDLE remote;
1367         HRESULT hr;
1368         BSTR component;
1369
1370         if (!(remote = msi_get_remote(hInstall)))
1371             return ERROR_INVALID_HANDLE;
1372
1373         component = SysAllocString(szComponent);
1374         if (!component)
1375             return ERROR_OUTOFMEMORY;
1376
1377         hr = remote_SetComponentState(remote, component, iState);
1378
1379         SysFreeString(component);
1380
1381         if (FAILED(hr))
1382         {
1383             if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
1384                 return HRESULT_CODE(hr);
1385
1386             return ERROR_FUNCTION_FAILED;
1387         }
1388
1389         return ERROR_SUCCESS;
1390     }
1391
1392     ret = MSI_SetComponentStateW(package, szComponent, iState);
1393     msiobj_release(&package->hdr);
1394     return ret;
1395 }
1396
1397 /***********************************************************************
1398  * MsiGetComponentStateW (MSI.@)
1399  */
1400 UINT WINAPI MsiGetComponentStateW(MSIHANDLE hInstall, LPCWSTR szComponent,
1401                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
1402 {
1403     MSIPACKAGE* package;
1404     UINT ret;
1405
1406     TRACE("%d %s %p %p\n", hInstall, debugstr_w(szComponent),
1407            piInstalled, piAction);
1408
1409     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1410     if (!package)
1411     {
1412         MSIHANDLE remote;
1413         HRESULT hr;
1414         BSTR component;
1415
1416         if (!(remote = msi_get_remote(hInstall)))
1417             return ERROR_INVALID_HANDLE;
1418
1419         component = SysAllocString(szComponent);
1420         if (!component)
1421             return ERROR_OUTOFMEMORY;
1422
1423         hr = remote_GetComponentState(remote, component, piInstalled, piAction);
1424
1425         SysFreeString(component);
1426
1427         if (FAILED(hr))
1428         {
1429             if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
1430                 return HRESULT_CODE(hr);
1431
1432             return ERROR_FUNCTION_FAILED;
1433         }
1434
1435         return ERROR_SUCCESS;
1436     }
1437
1438     ret = MSI_GetComponentStateW( package, szComponent, piInstalled, piAction);
1439     msiobj_release( &package->hdr );
1440     return ret;
1441 }
1442
1443 /***********************************************************************
1444  * MsiGetLanguage (MSI.@)
1445  */
1446 LANGID WINAPI MsiGetLanguage(MSIHANDLE hInstall)
1447 {
1448     MSIPACKAGE* package;
1449     LANGID langid;
1450
1451     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1452     if (!package)
1453     {
1454         MSIHANDLE remote;
1455         HRESULT hr;
1456         LANGID lang;
1457
1458         if (!(remote = msi_get_remote(hInstall)))
1459             return ERROR_INVALID_HANDLE;
1460
1461         hr = remote_GetLanguage(remote, &lang);
1462
1463         if (SUCCEEDED(hr))
1464             return lang;
1465
1466         return 0;
1467     }
1468
1469     langid = msi_get_property_int( package->db, szProductLanguage, 0 );
1470     msiobj_release( &package->hdr );
1471     return langid;
1472 }
1473
1474 UINT MSI_SetInstallLevel( MSIPACKAGE *package, int iInstallLevel )
1475 {
1476     static const WCHAR fmt[] = { '%','d',0 };
1477     WCHAR level[6];
1478     int len;
1479     UINT r;
1480
1481     TRACE("%p %i\n", package, iInstallLevel);
1482
1483     if (iInstallLevel > 32767)
1484         return ERROR_INVALID_PARAMETER;
1485
1486     if (iInstallLevel < 1)
1487         return MSI_SetFeatureStates( package );
1488
1489     len = sprintfW( level, fmt, iInstallLevel );
1490     r = msi_set_property( package->db, szInstallLevel, level, len );
1491     if ( r == ERROR_SUCCESS )
1492         r = MSI_SetFeatureStates( package );
1493
1494     return r;
1495 }
1496
1497 /***********************************************************************
1498  * MsiSetInstallLevel (MSI.@)
1499  */
1500 UINT WINAPI MsiSetInstallLevel(MSIHANDLE hInstall, int iInstallLevel)
1501 {
1502     MSIPACKAGE* package;
1503     UINT r;
1504
1505     TRACE("%d %i\n", hInstall, iInstallLevel);
1506
1507     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1508     if (!package)
1509     {
1510         MSIHANDLE remote;
1511         HRESULT hr;
1512
1513         if (!(remote = msi_get_remote(hInstall)))
1514             return ERROR_INVALID_HANDLE;
1515
1516         hr = remote_SetInstallLevel(remote, iInstallLevel);
1517
1518         if (FAILED(hr))
1519         {
1520             if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
1521                 return HRESULT_CODE(hr);
1522
1523             return ERROR_FUNCTION_FAILED;
1524         }
1525
1526         return ERROR_SUCCESS;
1527     }
1528
1529     r = MSI_SetInstallLevel( package, iInstallLevel );
1530
1531     msiobj_release( &package->hdr );
1532
1533     return r;
1534 }
1535
1536 /***********************************************************************
1537  * MsiGetFeatureValidStatesW (MSI.@)
1538  */
1539 UINT WINAPI MsiGetFeatureValidStatesW(MSIHANDLE hInstall, LPCWSTR szFeature,
1540                   LPDWORD pInstallState)
1541 {
1542     if(pInstallState) *pInstallState = 1<<INSTALLSTATE_LOCAL;
1543     FIXME("%d %s %p stub returning %d\n",
1544         hInstall, debugstr_w(szFeature), pInstallState, pInstallState ? *pInstallState : 0);
1545
1546     return ERROR_SUCCESS;
1547 }
1548
1549 /***********************************************************************
1550  * MsiGetFeatureValidStatesA (MSI.@)
1551  */
1552 UINT WINAPI MsiGetFeatureValidStatesA(MSIHANDLE hInstall, LPCSTR szFeature,
1553                   LPDWORD pInstallState)
1554 {
1555     UINT ret;
1556     LPWSTR szwFeature = strdupAtoW(szFeature);
1557
1558     ret = MsiGetFeatureValidStatesW(hInstall, szwFeature, pInstallState);
1559
1560     msi_free(szwFeature);
1561
1562     return ret;
1563 }