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