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
 565         if (!(remote = msi_get_remote(hInstall)))
 566             return FALSE;
 567
 568         return remote_GetMode(remote, iRunMode);
 569     }
 570
 571     switch (iRunMode)
 572     {
 573     case MSIRUNMODE_ADMIN:
 574         FIXME("no support for administrative installs\n");
 575         break;
 576
 577     case MSIRUNMODE_ADVERTISE:
 578         FIXME("no support for advertised installs\n");
 579         break;
 580
 581     case MSIRUNMODE_WINDOWS9X:
 582         if (GetVersion() & 0x80000000)
 583             r = TRUE;
 584         break;
 585
 586     case MSIRUNMODE_OPERATIONS:
 587     case MSIRUNMODE_RESERVED11:
 588     case MSIRUNMODE_RESERVED14:
 589     case MSIRUNMODE_RESERVED15:
 590         break;
 591
 592     case MSIRUNMODE_SCHEDULED:
 593         r = package->scheduled_action_running;
 594         break;
 595
 596     case MSIRUNMODE_ROLLBACK:
 597         r = package->rollback_action_running;
 598         break;
 599
 600     case MSIRUNMODE_COMMIT:
 601         r = package->commit_action_running;
 602         break;
 603
 604     case MSIRUNMODE_MAINTENANCE:
 605         r = msi_get_property_int( package->db, szInstalled, 0 ) != 0;
 606         break;
 607
 608     case MSIRUNMODE_ROLLBACKENABLED:
 609         r = msi_get_property_int( package->db, szRollbackDisabled, 0 ) == 0;
 610         break;
 611
 612     case MSIRUNMODE_REBOOTATEND:
 613         r = package->need_reboot_at_end;
 614         break;
 615
 616     case MSIRUNMODE_REBOOTNOW:
 617         r = package->need_reboot_now;
 618         break;
 619
 620     case MSIRUNMODE_LOGENABLED:
 621         r = (package->log_file != INVALID_HANDLE_VALUE);
 622         break;
 623
 624     default:
 625         FIXME("unimplemented run mode: %d\n", iRunMode);
 626         r = TRUE;
 627     }
 628
 629     msiobj_release( &package->hdr );
 630     return r;
 631 }
 632
 633 /***********************************************************************
 634  *           MsiSetMode    (MSI.@)
 635  */
 636 UINT WINAPI MsiSetMode(MSIHANDLE hInstall, MSIRUNMODE iRunMode, BOOL fState)
 637 {
 638     MSIPACKAGE *package;
 639     UINT r;
 640
 641     TRACE("%d %d %d\n", hInstall, iRunMode, fState);
 642
 643     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
 644     if (!package)
 645     {
 646         MSIHANDLE remote;
 647
 648         if (!(remote = msi_get_remote(hInstall)))
 649             return FALSE;
 650
 651         return remote_SetMode(remote, iRunMode, fState);
 652     }
 653
 654     switch (iRunMode)
 655     {
 656     case MSIRUNMODE_REBOOTATEND:
 657         package->need_reboot_at_end = (fState != 0);
 658         r = ERROR_SUCCESS;
 659         break;
 660
 661     case MSIRUNMODE_REBOOTNOW:
 662         package->need_reboot_now = (fState != 0);
 663         r = ERROR_SUCCESS;
 664         break;
 665
 666     default:
 667         r = ERROR_ACCESS_DENIED;
 668     }
 669
 670     msiobj_release( &package->hdr );
 671     return r;
 672 }
 673
 674 /***********************************************************************
 675  * MsiSetFeatureStateA (MSI.@)
 676  *
 677  * According to the docs, when this is called it immediately recalculates
 678  * all the component states as well
 679  */
 680 UINT WINAPI MsiSetFeatureStateA(MSIHANDLE hInstall, LPCSTR szFeature,
 681                                 INSTALLSTATE iState)
 682 {
 683     LPWSTR szwFeature = NULL;
 684     UINT rc;
 685
 686     szwFeature = strdupAtoW(szFeature);
 687
 688     rc = MsiSetFeatureStateW(hInstall,szwFeature, iState);
 689
 690     msi_free(szwFeature);
 691
 692     return rc;
 693 }
 694
 695 /* update component state based on a feature change */
 696 void ACTION_UpdateComponentStates( MSIPACKAGE *package, MSIFEATURE *feature )
 697 {
 698     INSTALLSTATE newstate;
 699     ComponentList *cl;
 700
 701     newstate = feature->ActionRequest;
 702     if (newstate == INSTALLSTATE_ABSENT) newstate = INSTALLSTATE_UNKNOWN;
 703
 704     LIST_FOR_EACH_ENTRY(cl, &feature->Components, ComponentList, entry)
 705     {
 706         MSICOMPONENT *component = cl->component;
 707
 708         if (!component->Enabled) continue;
 709
 710         TRACE("Modifying (%d): Component %s (Installed %d, Action %d, Request %d)\n",
 711             newstate, debugstr_w(component->Component), component->Installed,
 712             component->Action, component->ActionRequest);
 713
 714         if (newstate == INSTALLSTATE_LOCAL)
 715         {
 716             component->Action = INSTALLSTATE_LOCAL;
 717             component->ActionRequest = INSTALLSTATE_LOCAL;
 718         }
 719         else
 720         {
 721             ComponentList *clist;
 722             MSIFEATURE *f;
 723
 724             component->hasLocalFeature = FALSE;
 725
 726             component->Action = newstate;
 727             component->ActionRequest = newstate;
 728             /* if any other feature wants it local we need to set it local */
 729             LIST_FOR_EACH_ENTRY(f, &package->features, MSIFEATURE, entry)
 730             {
 731                 if ( f->ActionRequest != INSTALLSTATE_LOCAL &&
 732                      f->ActionRequest != INSTALLSTATE_SOURCE )
 733                 {
 734                     continue;
 735                 }
 736                 LIST_FOR_EACH_ENTRY(clist, &f->Components, ComponentList, entry)
 737                 {
 738                     if (clist->component == component &&
 739                         (f->ActionRequest == INSTALLSTATE_LOCAL ||
 740                          f->ActionRequest == INSTALLSTATE_SOURCE))
 741                     {
 742                         TRACE("Saved by %s\n", debugstr_w(f->Feature));
 743                         component->hasLocalFeature = TRUE;
 744
 745                         if (component->Attributes & msidbComponentAttributesOptional)
 746                         {
 747                             if (f->Attributes & msidbFeatureAttributesFavorSource)
 748                             {
 749                                 component->Action = INSTALLSTATE_SOURCE;
 750                                 component->ActionRequest = INSTALLSTATE_SOURCE;
 751                             }
 752                             else
 753                             {
 754                                 component->Action = INSTALLSTATE_LOCAL;
 755                                 component->ActionRequest = INSTALLSTATE_LOCAL;
 756                             }
 757                         }
 758                         else if (component->Attributes & msidbComponentAttributesSourceOnly)
 759                         {
 760                             component->Action = INSTALLSTATE_SOURCE;
 761                             component->ActionRequest = INSTALLSTATE_SOURCE;
 762                         }
 763                         else
 764                         {
 765                             component->Action = INSTALLSTATE_LOCAL;
 766                             component->ActionRequest = INSTALLSTATE_LOCAL;
 767                         }
 768                     }
 769                 }
 770             }
 771         }
 772         TRACE("Result (%d): Component %s (Installed %d, Action %d, Request %d)\n",
 773             newstate, debugstr_w(component->Component), component->Installed,
 774             component->Action, component->ActionRequest);
 775     }
 776 }
 777
 778 UINT MSI_SetFeatureStateW( MSIPACKAGE *package, LPCWSTR szFeature, INSTALLSTATE iState )
 779 {
 780     UINT rc = ERROR_SUCCESS;
 781     MSIFEATURE *feature, *child;
 782
 783     TRACE("%s %i\n", debugstr_w(szFeature), iState);
 784
 785     feature = msi_get_loaded_feature( package, szFeature );
 786     if (!feature)
 787         return ERROR_UNKNOWN_FEATURE;
 788
 789     if (iState == INSTALLSTATE_ADVERTISED &&
 790         feature->Attributes & msidbFeatureAttributesDisallowAdvertise)
 791         return ERROR_FUNCTION_FAILED;
 792
 793     feature->ActionRequest = iState;
 794
 795     ACTION_UpdateComponentStates( package, feature );
 796
 797     /* update all the features that are children of this feature */
 798     LIST_FOR_EACH_ENTRY( child, &package->features, MSIFEATURE, entry )
 799     {
 800         if (child->Feature_Parent && !strcmpW( szFeature, child->Feature_Parent ))
 801             MSI_SetFeatureStateW(package, child->Feature, iState);
 802     }
 803
 804     return rc;
 805 }
 806
 807 /***********************************************************************
 808  * MsiSetFeatureStateW (MSI.@)
 809  */
 810 UINT WINAPI MsiSetFeatureStateW(MSIHANDLE hInstall, LPCWSTR szFeature,
 811                                 INSTALLSTATE iState)
 812 {
 813     MSIPACKAGE* package;
 814     UINT rc = ERROR_SUCCESS;
 815
 816     TRACE("%s %i\n",debugstr_w(szFeature), iState);
 817
 818     if (!szFeature)
 819         return ERROR_UNKNOWN_FEATURE;
 820
 821     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 822     if (!package)
 823     {
 824         MSIHANDLE remote;
 825
 826         if (!(remote = msi_get_remote(hInstall)))
 827             return ERROR_INVALID_HANDLE;
 828
 829         return remote_SetFeatureState(remote, szFeature, iState);
 830     }
 831
 832     rc = MSI_SetFeatureStateW(package,szFeature,iState);
 833
 834     msiobj_release( &package->hdr );
 835     return rc;
 836 }
 837
 838 /***********************************************************************
 839 * MsiSetFeatureAttributesA   (MSI.@)
 840 */
 841 UINT WINAPI MsiSetFeatureAttributesA( MSIHANDLE handle, LPCSTR feature, DWORD attrs )
 842 {
 843     UINT r;
 844     WCHAR *featureW = NULL;
 845
 846     TRACE("%u, %s, 0x%08x\n", handle, debugstr_a(feature), attrs);
 847
 848     if (feature && !(featureW = strdupAtoW( feature ))) return ERROR_OUTOFMEMORY;
 849
 850     r = MsiSetFeatureAttributesW( handle, featureW, attrs );
 851     msi_free( featureW );
 852     return r;
 853 }
 854
 855 static DWORD unmap_feature_attributes( DWORD attrs )
 856 {
 857     DWORD ret = 0;
 858
 859     if (attrs & INSTALLFEATUREATTRIBUTE_FAVORLOCAL)             ret = msidbFeatureAttributesFavorLocal;
 860     if (attrs & INSTALLFEATUREATTRIBUTE_FAVORSOURCE)            ret |= msidbFeatureAttributesFavorSource;
 861     if (attrs & INSTALLFEATUREATTRIBUTE_FOLLOWPARENT)           ret |= msidbFeatureAttributesFollowParent;
 862     if (attrs & INSTALLFEATUREATTRIBUTE_FAVORADVERTISE)         ret |= msidbFeatureAttributesFavorAdvertise;
 863     if (attrs & INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE)      ret |= msidbFeatureAttributesDisallowAdvertise;
 864     if (attrs & INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE) ret |= msidbFeatureAttributesNoUnsupportedAdvertise;
 865     return ret;
 866 }
 867
 868 /***********************************************************************
 869 * MsiSetFeatureAttributesW   (MSI.@)
 870 */
 871 UINT WINAPI MsiSetFeatureAttributesW( MSIHANDLE handle, LPCWSTR name, DWORD attrs )
 872 {
 873     MSIPACKAGE *package;
 874     MSIFEATURE *feature;
 875     WCHAR *costing;
 876
 877     TRACE("%u, %s, 0x%08x\n", handle, debugstr_w(name), attrs);
 878
 879     if (!name || !name[0]) return ERROR_UNKNOWN_FEATURE;
 880
 881     if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE )))
 882         return ERROR_INVALID_HANDLE;
 883
 884     costing = msi_dup_property( package->db, szCostingComplete );
 885     if (!costing || !strcmpW( costing, szOne ))
 886     {
 887         msi_free( costing );
 888         msiobj_release( &package->hdr );
 889         return ERROR_FUNCTION_FAILED;
 890     }
 891     msi_free( costing );
 892     if (!(feature = msi_get_loaded_feature( package, name )))
 893     {
 894         msiobj_release( &package->hdr );
 895         return ERROR_UNKNOWN_FEATURE;
 896     }
 897     feature->Attributes = unmap_feature_attributes( attrs );
 898     msiobj_release( &package->hdr );
 899     return ERROR_SUCCESS;
 900 }
 901
 902 /***********************************************************************
 903 * MsiGetFeatureStateA   (MSI.@)
 904 */
 905 UINT WINAPI MsiGetFeatureStateA(MSIHANDLE hInstall, LPCSTR szFeature,
 906                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
 907 {
 908     LPWSTR szwFeature = NULL;
 909     UINT rc;
 910
 911     if (szFeature && !(szwFeature = strdupAtoW(szFeature))) return ERROR_OUTOFMEMORY;
 912
 913     rc = MsiGetFeatureStateW(hInstall, szwFeature, piInstalled, piAction);
 914     msi_free( szwFeature);
 915     return rc;
 916 }
 917
 918 UINT MSI_GetFeatureStateW(MSIPACKAGE *package, LPCWSTR szFeature,
 919                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
 920 {
 921     MSIFEATURE *feature;
 922
 923     feature = msi_get_loaded_feature(package,szFeature);
 924     if (!feature)
 925         return ERROR_UNKNOWN_FEATURE;
 926
 927     if (piInstalled)
 928         *piInstalled = feature->Installed;
 929
 930     if (piAction)
 931         *piAction = feature->ActionRequest;
 932
 933     TRACE("returning %i %i\n", feature->Installed, feature->ActionRequest);
 934
 935     return ERROR_SUCCESS;
 936 }
 937
 938 /***********************************************************************
 939 * MsiGetFeatureStateW   (MSI.@)
 940 */
 941 UINT WINAPI MsiGetFeatureStateW(MSIHANDLE hInstall, LPCWSTR szFeature,
 942                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
 943 {
 944     MSIPACKAGE* package;
 945     UINT ret;
 946
 947     TRACE("%d %s %p %p\n", hInstall, debugstr_w(szFeature), piInstalled, piAction);
 948
 949     if (!szFeature)
 950         return ERROR_UNKNOWN_FEATURE;
 951
 952     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 953     if (!package)
 954     {
 955         MSIHANDLE remote;
 956
 957         if (!(remote = msi_get_remote(hInstall)))
 958             return ERROR_INVALID_HANDLE;
 959
 960         /* FIXME: should use SEH */
 961         if (!piInstalled || !piAction)
 962             return RPC_X_NULL_REF_POINTER;
 963
 964         return remote_GetFeatureState(remote, szFeature, piInstalled, piAction);
 965     }
 966
 967     ret = MSI_GetFeatureStateW(package, szFeature, piInstalled, piAction);
 968     msiobj_release( &package->hdr );
 969     return ret;
 970 }
 971
 972 /***********************************************************************
 973 * MsiGetFeatureCostA   (MSI.@)
 974 */
 975 UINT WINAPI MsiGetFeatureCostA(MSIHANDLE hInstall, LPCSTR szFeature,
 976                   MSICOSTTREE iCostTree, INSTALLSTATE iState, LPINT piCost)
 977 {
 978     LPWSTR szwFeature = NULL;
 979     UINT rc;
 980
 981     szwFeature = strdupAtoW(szFeature);
 982
 983     rc = MsiGetFeatureCostW(hInstall, szwFeature, iCostTree, iState, piCost);
 984
 985     msi_free(szwFeature);
 986
 987     return rc;
 988 }
 989
 990 static INT feature_cost( MSIFEATURE *feature )
 991 {
 992     INT cost = 0;
 993     ComponentList *cl;
 994
 995     LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
 996     {
 997         cost += cl->component->Cost;
 998     }
 999     return cost;
1000 }
1001
1002 UINT MSI_GetFeatureCost( MSIPACKAGE *package, MSIFEATURE *feature, MSICOSTTREE tree,
1003                          INSTALLSTATE state, LPINT cost )
1004 {
1005     TRACE("%s, %u, %d, %p\n", debugstr_w(feature->Feature), tree, state, cost);
1006
1007     *cost = 0;
1008     switch (tree)
1009     {
1010     case MSICOSTTREE_CHILDREN:
1011     {
1012         MSIFEATURE *child;
1013
1014         LIST_FOR_EACH_ENTRY( child, &feature->Children, MSIFEATURE, entry )
1015         {
1016             if (child->ActionRequest == state)
1017                 *cost += feature_cost( child );
1018         }
1019         break;
1020     }
1021     case MSICOSTTREE_PARENTS:
1022     {
1023         const WCHAR *feature_parent = feature->Feature_Parent;
1024         for (;;)
1025         {
1026             MSIFEATURE *parent = msi_get_loaded_feature( package, feature_parent );
1027             if (!parent)
1028                 break;
1029
1030             if (parent->ActionRequest == state)
1031                 *cost += feature_cost( parent );
1032
1033             feature_parent = parent->Feature_Parent;
1034         }
1035         break;
1036     }
1037     case MSICOSTTREE_SELFONLY:
1038         if (feature->ActionRequest == state)
1039             *cost = feature_cost( feature );
1040         break;
1041
1042     default:
1043         WARN("unhandled cost tree %u\n", tree);
1044         break;
1045     }
1046
1047     *cost /= 512;
1048     return ERROR_SUCCESS;
1049 }
1050
1051 /***********************************************************************
1052 * MsiGetFeatureCostW   (MSI.@)
1053 */
1054 UINT WINAPI MsiGetFeatureCostW(MSIHANDLE hInstall, LPCWSTR szFeature,
1055                   MSICOSTTREE iCostTree, INSTALLSTATE iState, LPINT piCost)
1056 {
1057     MSIPACKAGE *package;
1058     MSIFEATURE *feature;
1059     UINT ret;
1060
1061     TRACE("(%d %s %i %i %p)\n", hInstall, debugstr_w(szFeature),
1062           iCostTree, iState, piCost);
1063
1064     if (!szFeature)
1065         return ERROR_INVALID_PARAMETER;
1066
1067     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1068     if (!package)
1069     {
1070         MSIHANDLE remote;
1071
1072         if (!(remote = msi_get_remote(hInstall)))
1073             return ERROR_INVALID_HANDLE;
1074
1075         /* FIXME: should use SEH */
1076         if (!piCost)
1077             return RPC_X_NULL_REF_POINTER;
1078
1079         return remote_GetFeatureCost(remote, szFeature, iCostTree, iState, piCost);
1080     }
1081
1082     if (!piCost)
1083     {
1084         msiobj_release( &package->hdr );
1085         return ERROR_INVALID_PARAMETER;
1086     }
1087
1088     feature = msi_get_loaded_feature(package, szFeature);
1089
1090     if (feature)
1091         ret = MSI_GetFeatureCost(package, feature, iCostTree, iState, piCost);
1092     else
1093         ret = ERROR_UNKNOWN_FEATURE;
1094
1095     msiobj_release( &package->hdr );
1096     return ret;
1097 }
1098
1099 /***********************************************************************
1100 * MsiGetFeatureInfoA   (MSI.@)
1101 */
1102 UINT WINAPI MsiGetFeatureInfoA( MSIHANDLE handle, LPCSTR feature, LPDWORD attrs,
1103                                 LPSTR title, LPDWORD title_len, LPSTR help, LPDWORD help_len )
1104 {
1105     UINT r;
1106     WCHAR *titleW = NULL, *helpW = NULL, *featureW = NULL;
1107
1108     TRACE("%u, %s, %p, %p, %p, %p, %p\n", handle, debugstr_a(feature), attrs, title,
1109           title_len, help, help_len);
1110
1111     if (feature && !(featureW = strdupAtoW( feature ))) return ERROR_OUTOFMEMORY;
1112
1113     if (title && title_len && !(titleW = msi_alloc( *title_len * sizeof(WCHAR) )))
1114     {
1115         msi_free( featureW );
1116         return ERROR_OUTOFMEMORY;
1117     }
1118     if (help && help_len && !(helpW = msi_alloc( *help_len * sizeof(WCHAR) )))
1119     {
1120         msi_free( featureW );
1121         msi_free( titleW );
1122         return ERROR_OUTOFMEMORY;
1123     }
1124     r = MsiGetFeatureInfoW( handle, featureW, attrs, titleW, title_len, helpW, help_len );
1125     if (r == ERROR_SUCCESS)
1126     {
1127         if (titleW) WideCharToMultiByte( CP_ACP, 0, titleW, -1, title, *title_len + 1, NULL, NULL );
1128         if (helpW) WideCharToMultiByte( CP_ACP, 0, helpW, -1, help, *help_len + 1, NULL, NULL );
1129     }
1130     msi_free( titleW );
1131     msi_free( helpW );
1132     msi_free( featureW );
1133     return r;
1134 }
1135
1136 static DWORD map_feature_attributes( DWORD attrs )
1137 {
1138     DWORD ret = 0;
1139
1140     if (attrs == msidbFeatureAttributesFavorLocal)            ret |= INSTALLFEATUREATTRIBUTE_FAVORLOCAL;
1141     if (attrs & msidbFeatureAttributesFavorSource)            ret |= INSTALLFEATUREATTRIBUTE_FAVORSOURCE;
1142     if (attrs & msidbFeatureAttributesFollowParent)           ret |= INSTALLFEATUREATTRIBUTE_FOLLOWPARENT;
1143     if (attrs & msidbFeatureAttributesFavorAdvertise)         ret |= INSTALLFEATUREATTRIBUTE_FAVORADVERTISE;
1144     if (attrs & msidbFeatureAttributesDisallowAdvertise)      ret |= INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE;
1145     if (attrs & msidbFeatureAttributesNoUnsupportedAdvertise) ret |= INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE;
1146     return ret;
1147 }
1148
1149 static UINT MSI_GetFeatureInfo( MSIPACKAGE *package, LPCWSTR name, LPDWORD attrs,
1150                                 LPWSTR title, LPDWORD title_len, LPWSTR help, LPDWORD help_len )
1151 {
1152     UINT r = ERROR_SUCCESS;
1153     MSIFEATURE *feature = msi_get_loaded_feature( package, name );
1154     int len;
1155
1156     if (!feature) return ERROR_UNKNOWN_FEATURE;
1157     if (attrs) *attrs = map_feature_attributes( feature->Attributes );
1158     if (title_len)
1159     {
1160         if (feature->Title) len = strlenW( feature->Title );
1161         else len = 0;
1162         if (*title_len <= len)
1163         {
1164             *title_len = len;
1165             if (title) r = ERROR_MORE_DATA;
1166         }
1167         else if (title)
1168         {
1169             if (feature->Title) strcpyW( title, feature->Title );
1170             else *title = 0;
1171             *title_len = len;
1172         }
1173     }
1174     if (help_len)
1175     {
1176         if (feature->Description) len = strlenW( feature->Description );
1177         else len = 0;
1178         if (*help_len <= len)
1179         {
1180             *help_len = len;
1181             if (help) r = ERROR_MORE_DATA;
1182         }
1183         else if (help)
1184         {
1185             if (feature->Description) strcpyW( help, feature->Description );
1186             else *help = 0;
1187             *help_len = len;
1188         }
1189     }
1190     return r;
1191 }
1192
1193 /***********************************************************************
1194 * MsiGetFeatureInfoW   (MSI.@)
1195 */
1196 UINT WINAPI MsiGetFeatureInfoW( MSIHANDLE handle, LPCWSTR feature, LPDWORD attrs,
1197                                 LPWSTR title, LPDWORD title_len, LPWSTR help, LPDWORD help_len )
1198 {
1199     UINT r;
1200     MSIPACKAGE *package;
1201
1202     TRACE("%u, %s, %p, %p, %p, %p, %p\n", handle, debugstr_w(feature), attrs, title,
1203           title_len, help, help_len);
1204
1205     if (!feature) return ERROR_INVALID_PARAMETER;
1206
1207     if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE )))
1208         return ERROR_INVALID_HANDLE;
1209
1210     /* features may not have been loaded yet */
1211     msi_load_all_components( package );
1212     msi_load_all_features( package );
1213
1214     r = MSI_GetFeatureInfo( package, feature, attrs, title, title_len, help, help_len );
1215     msiobj_release( &package->hdr );
1216     return r;
1217 }
1218
1219 /***********************************************************************
1220  * MsiSetComponentStateA (MSI.@)
1221  */
1222 UINT WINAPI MsiSetComponentStateA(MSIHANDLE hInstall, LPCSTR szComponent,
1223                                   INSTALLSTATE iState)
1224 {
1225     UINT rc;
1226     LPWSTR szwComponent = strdupAtoW(szComponent);
1227
1228     rc = MsiSetComponentStateW(hInstall, szwComponent, iState);
1229
1230     msi_free(szwComponent);
1231
1232     return rc;
1233 }
1234
1235 /***********************************************************************
1236  * MsiGetComponentStateA (MSI.@)
1237  */
1238 UINT WINAPI MsiGetComponentStateA(MSIHANDLE hInstall, LPCSTR szComponent,
1239                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
1240 {
1241     LPWSTR szwComponent= NULL;
1242     UINT rc;
1243
1244     szwComponent= strdupAtoW(szComponent);
1245
1246     rc = MsiGetComponentStateW(hInstall,szwComponent,piInstalled, piAction);
1247
1248     msi_free( szwComponent);
1249
1250     return rc;
1251 }
1252
1253 static UINT MSI_SetComponentStateW(MSIPACKAGE *package, LPCWSTR szComponent,
1254                                    INSTALLSTATE iState)
1255 {
1256     MSICOMPONENT *comp;
1257
1258     TRACE("%p %s %d\n", package, debugstr_w(szComponent), iState);
1259
1260     comp = msi_get_loaded_component(package, szComponent);
1261     if (!comp)
1262         return ERROR_UNKNOWN_COMPONENT;
1263
1264     if (comp->Enabled)
1265         comp->Action = iState;
1266
1267     return ERROR_SUCCESS;
1268 }
1269
1270 UINT MSI_GetComponentStateW(MSIPACKAGE *package, LPCWSTR szComponent,
1271                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
1272 {
1273     MSICOMPONENT *comp;
1274
1275     TRACE("%p %s %p %p\n", package, debugstr_w(szComponent),
1276            piInstalled, piAction);
1277
1278     comp = msi_get_loaded_component(package,szComponent);
1279     if (!comp)
1280         return ERROR_UNKNOWN_COMPONENT;
1281
1282     if (piInstalled)
1283     {
1284         if (comp->Enabled)
1285             *piInstalled = comp->Installed;
1286         else
1287             *piInstalled = INSTALLSTATE_UNKNOWN;
1288     }
1289
1290     if (piAction)
1291     {
1292         if (comp->Enabled)
1293             *piAction = comp->Action;
1294         else
1295             *piAction = INSTALLSTATE_UNKNOWN;
1296     }
1297
1298     TRACE("states (%i, %i)\n", comp->Installed, comp->Action );
1299     return ERROR_SUCCESS;
1300 }
1301
1302 /***********************************************************************
1303  * MsiSetComponentStateW (MSI.@)
1304  */
1305 UINT WINAPI MsiSetComponentStateW(MSIHANDLE hInstall, LPCWSTR szComponent,
1306                                   INSTALLSTATE iState)
1307 {
1308     MSIPACKAGE* package;
1309     UINT ret;
1310
1311     if (!szComponent)
1312         return ERROR_UNKNOWN_COMPONENT;
1313
1314     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1315     if (!package)
1316     {
1317         MSIHANDLE remote;
1318
1319         if (!(remote = msi_get_remote(hInstall)))
1320             return ERROR_INVALID_HANDLE;
1321
1322         return remote_SetComponentState(remote, szComponent, iState);
1323     }
1324
1325     ret = MSI_SetComponentStateW(package, szComponent, iState);
1326     msiobj_release(&package->hdr);
1327     return ret;
1328 }
1329
1330 /***********************************************************************
1331  * MsiGetComponentStateW (MSI.@)
1332  */
1333 UINT WINAPI MsiGetComponentStateW(MSIHANDLE hInstall, LPCWSTR szComponent,
1334                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
1335 {
1336     MSIPACKAGE* package;
1337     UINT ret;
1338
1339     TRACE("%d %s %p %p\n", hInstall, debugstr_w(szComponent),
1340            piInstalled, piAction);
1341
1342     if (!szComponent)
1343         return ERROR_UNKNOWN_COMPONENT;
1344
1345     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1346     if (!package)
1347     {
1348         MSIHANDLE remote;
1349
1350         if (!(remote = msi_get_remote(hInstall)))
1351             return ERROR_INVALID_HANDLE;
1352
1353         /* FIXME: should use SEH */
1354         if (!piInstalled || !piAction)
1355             return RPC_X_NULL_REF_POINTER;
1356
1357         return remote_GetComponentState(remote, szComponent, piInstalled, piAction);
1358     }
1359
1360     ret = MSI_GetComponentStateW( package, szComponent, piInstalled, piAction);
1361     msiobj_release( &package->hdr );
1362     return ret;
1363 }
1364
1365 /***********************************************************************
1366  * MsiGetLanguage (MSI.@)
1367  */
1368 LANGID WINAPI MsiGetLanguage(MSIHANDLE hInstall)
1369 {
1370     MSIPACKAGE* package;
1371     LANGID langid;
1372
1373     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1374     if (!package)
1375     {
1376         MSIHANDLE remote;
1377
1378         if (!(remote = msi_get_remote(hInstall)))
1379             return ERROR_INVALID_HANDLE;
1380
1381         return remote_GetLanguage(remote);
1382     }
1383
1384     langid = msi_get_property_int( package->db, szProductLanguage, 0 );
1385     msiobj_release( &package->hdr );
1386     return langid;
1387 }
1388
1389 UINT MSI_SetInstallLevel( MSIPACKAGE *package, int iInstallLevel )
1390 {
1391     static const WCHAR fmt[] = { '%','d',0 };
1392     WCHAR level[6];
1393     int len;
1394     UINT r;
1395
1396     TRACE("%p %i\n", package, iInstallLevel);
1397
1398     if (iInstallLevel > 32767)
1399         return ERROR_INVALID_PARAMETER;
1400
1401     if (iInstallLevel < 1)
1402         return MSI_SetFeatureStates( package );
1403
1404     len = sprintfW( level, fmt, iInstallLevel );
1405     r = msi_set_property( package->db, szInstallLevel, level, len );
1406     if ( r == ERROR_SUCCESS )
1407         r = MSI_SetFeatureStates( package );
1408
1409     return r;
1410 }
1411
1412 /***********************************************************************
1413  * MsiSetInstallLevel (MSI.@)
1414  */
1415 UINT WINAPI MsiSetInstallLevel(MSIHANDLE hInstall, int iInstallLevel)
1416 {
1417     MSIPACKAGE* package;
1418     UINT r;
1419
1420     TRACE("%d %i\n", hInstall, iInstallLevel);
1421
1422     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1423     if (!package)
1424     {
1425         MSIHANDLE remote;
1426
1427         if (!(remote = msi_get_remote(hInstall)))
1428             return ERROR_INVALID_HANDLE;
1429
1430         return remote_SetInstallLevel(remote, iInstallLevel);
1431     }
1432
1433     r = MSI_SetInstallLevel( package, iInstallLevel );
1434
1435     msiobj_release( &package->hdr );
1436
1437     return r;
1438 }
1439
1440 /***********************************************************************
1441  * MsiGetFeatureValidStatesW (MSI.@)
1442  */
1443 UINT WINAPI MsiGetFeatureValidStatesW(MSIHANDLE hInstall, LPCWSTR szFeature,
1444                   LPDWORD pInstallState)
1445 {
1446     if(pInstallState) *pInstallState = 1<<INSTALLSTATE_LOCAL;
1447     FIXME("%d %s %p stub returning %d\n",
1448         hInstall, debugstr_w(szFeature), pInstallState, pInstallState ? *pInstallState : 0);
1449
1450     return ERROR_SUCCESS;
1451 }
1452
1453 /***********************************************************************
1454  * MsiGetFeatureValidStatesA (MSI.@)
1455  */
1456 UINT WINAPI MsiGetFeatureValidStatesA(MSIHANDLE hInstall, LPCSTR szFeature,
1457                   LPDWORD pInstallState)
1458 {
1459     UINT ret;
1460     LPWSTR szwFeature = strdupAtoW(szFeature);
1461
1462     ret = MsiGetFeatureValidStatesW(hInstall, szwFeature, pInstallState);
1463
1464     msi_free(szwFeature);
1465
1466     return ret;
1467 }