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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /* Msi top level apis directly related to installs */
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winerror.h"
  28 #include "wine/debug.h"
  29 #include "msi.h"
  30 #include "msidefs.h"
  31 #include "msipriv.h"
  32 #include "winuser.h"
  33 #include "wine/unicode.h"
  34 #include "action.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  37
  38 /***********************************************************************
  39  * MsiDoActionA       (MSI.@)
  40  */
  41 UINT WINAPI MsiDoActionA( MSIHANDLE hInstall, LPCSTR szAction )
  42 {
  43     LPWSTR szwAction;
  44     UINT ret;
  45
  46     TRACE("%s\n", debugstr_a(szAction));
  47
  48     szwAction = strdupAtoW(szAction);
  49     if (szAction && !szwAction)
  50         return ERROR_FUNCTION_FAILED;
  51
  52     ret = MsiDoActionW( hInstall, szwAction );
  53     msi_free( szwAction );
  54     return ret;
  55 }
  56
  57 /***********************************************************************
  58  * MsiDoActionW       (MSI.@)
  59  */
  60 UINT WINAPI MsiDoActionW( MSIHANDLE hInstall, LPCWSTR szAction )
  61 {
  62     MSIPACKAGE *package;
  63     UINT ret;
  64
  65     TRACE("%s\n",debugstr_w(szAction));
  66
  67     if (!szAction)
  68         return ERROR_INVALID_PARAMETER;
  69
  70     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
  71     if (!package)
  72         return ERROR_INVALID_HANDLE;
  73
  74     ret = ACTION_PerformUIAction( package, szAction );
  75     msiobj_release( &package->hdr );
  76
  77     return ret;
  78 }
  79
  80 /***********************************************************************
  81  * MsiSequenceA       (MSI.@)
  82  */
  83 UINT WINAPI MsiSequenceA( MSIHANDLE hInstall, LPCSTR szAction, INT iSequenceMode )
  84 {
  85     TRACE("%s\n", debugstr_a(szAction));
  86     return ERROR_CALL_NOT_IMPLEMENTED;
  87 }
  88
  89 /***********************************************************************
  90  * MsiSequenceW       (MSI.@)
  91  */
  92 UINT WINAPI MsiSequenceW( MSIHANDLE hInstall, LPCWSTR szAction, INT iSequenceMode )
  93 {
  94     TRACE("%s\n", debugstr_w(szAction));
  95     return ERROR_CALL_NOT_IMPLEMENTED;
  96 }
  97
  98 static UINT msi_strcpy_to_awstring( LPCWSTR str, awstring *awbuf, DWORD *sz )
  99 {
 100     UINT len, r = ERROR_SUCCESS;
 101
 102     if (awbuf->str.w && !sz )
 103         return ERROR_INVALID_PARAMETER;
 104
 105     if (!sz)
 106         return r;
 107
 108     if (awbuf->unicode)
 109     {
 110         len = lstrlenW( str );
 111         if (awbuf->str.w)
 112             lstrcpynW( awbuf->str.w, str, *sz );
 113     }
 114     else
 115     {
 116         len = WideCharToMultiByte( CP_ACP, 0, str, -1,
 117                            awbuf->str.a, *sz, NULL, NULL );
 118         len--;
 119     }
 120
 121     if (len >= *sz)
 122         r = ERROR_MORE_DATA;
 123     *sz = len;
 124     return r;
 125 }
 126
 127 /***********************************************************************
 128  * MsiGetTargetPath   (internal)
 129  */
 130 UINT WINAPI MSI_GetTargetPath( MSIHANDLE hInstall, LPCWSTR szFolder,
 131                                awstring *szPathBuf, DWORD* pcchPathBuf )
 132 {
 133     MSIPACKAGE *package;
 134     LPWSTR path;
 135     UINT r;
 136
 137     if (!szFolder)
 138         return ERROR_INVALID_PARAMETER;
 139
 140     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
 141     if (!package)
 142         return ERROR_INVALID_HANDLE;
 143
 144     path = resolve_folder( package, szFolder, FALSE, FALSE, NULL );
 145     msiobj_release( &package->hdr );
 146
 147     if (!path)
 148         return ERROR_DIRECTORY;
 149
 150     r = msi_strcpy_to_awstring( path, szPathBuf, pcchPathBuf );
 151     msi_free( path );
 152     return r;
 153 }
 154
 155 /***********************************************************************
 156  * MsiGetTargetPathA        (MSI.@)
 157  */
 158 UINT WINAPI MsiGetTargetPathA( MSIHANDLE hInstall, LPCSTR szFolder,
 159                                LPSTR szPathBuf, DWORD* pcchPathBuf )
 160 {
 161     LPWSTR szwFolder;
 162     awstring path;
 163     UINT r;
 164
 165     TRACE("%s %p %p\n", debugstr_a(szFolder), szPathBuf, pcchPathBuf);
 166
 167     szwFolder = strdupAtoW(szFolder);
 168     if (szFolder && !szwFolder)
 169         return ERROR_FUNCTION_FAILED;
 170
 171     path.unicode = FALSE;
 172     path.str.a = szPathBuf;
 173
 174     r = MSI_GetTargetPath( hInstall, szwFolder, &path, pcchPathBuf );
 175
 176     msi_free( szwFolder );
 177
 178     return r;
 179 }
 180
 181 /***********************************************************************
 182  * MsiGetTargetPathW        (MSI.@)
 183  */
 184 UINT WINAPI MsiGetTargetPathW( MSIHANDLE hInstall, LPCWSTR szFolder,
 185                                LPWSTR szPathBuf, DWORD* pcchPathBuf )
 186 {
 187     awstring path;
 188
 189     TRACE("%s %p %p\n", debugstr_w(szFolder), szPathBuf, pcchPathBuf);
 190
 191     path.unicode = TRUE;
 192     path.str.w = szPathBuf;
 193
 194     return MSI_GetTargetPath( hInstall, szFolder, &path, pcchPathBuf );
 195 }
 196
 197 /***********************************************************************
 198  * MsiGetSourcePath   (internal)
 199  */
 200 static UINT MSI_GetSourcePath( MSIHANDLE hInstall, LPCWSTR szFolder,
 201                                awstring *szPathBuf, DWORD* pcchPathBuf )
 202 {
 203     MSIPACKAGE *package;
 204     LPWSTR path;
 205     UINT r;
 206
 207     TRACE("%s %p %p\n", debugstr_w(szFolder), szPathBuf, pcchPathBuf );
 208
 209     if (!szFolder)
 210         return ERROR_INVALID_PARAMETER;
 211
 212     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 213     if (!package)
 214         return ERROR_INVALID_HANDLE;
 215
 216     if (szPathBuf->str.w && !pcchPathBuf )
 217     {
 218         msiobj_release( &package->hdr );
 219         return ERROR_INVALID_PARAMETER;
 220     }
 221
 222     path = resolve_folder(package, szFolder, TRUE, FALSE, NULL);
 223     msiobj_release( &package->hdr );
 224
 225     TRACE("path = %s\n",debugstr_w(path));
 226     if (!path)
 227         return ERROR_DIRECTORY;
 228
 229     r = msi_strcpy_to_awstring( path, szPathBuf, pcchPathBuf );
 230     msi_free( path );
 231     return r;
 232 }
 233
 234 /***********************************************************************
 235  * MsiGetSourcePathA     (MSI.@)
 236  */
 237 UINT WINAPI MsiGetSourcePathA( MSIHANDLE hInstall, LPCSTR szFolder,
 238                                LPSTR szPathBuf, DWORD* pcchPathBuf )
 239 {
 240     LPWSTR folder;
 241     awstring str;
 242     UINT r;
 243
 244     TRACE("%s %p %p\n", szFolder, debugstr_a(szPathBuf), pcchPathBuf);
 245
 246     str.unicode = FALSE;
 247     str.str.a = szPathBuf;
 248
 249     folder = strdupAtoW( szFolder );
 250     r = MSI_GetSourcePath( hInstall, folder, &str, pcchPathBuf );
 251     msi_free( folder );
 252
 253     return r;
 254 }
 255
 256 /***********************************************************************
 257  * MsiGetSourcePathW     (MSI.@)
 258  */
 259 UINT WINAPI MsiGetSourcePathW( MSIHANDLE hInstall, LPCWSTR szFolder,
 260                                LPWSTR szPathBuf, DWORD* pcchPathBuf )
 261 {
 262     awstring str;
 263
 264     TRACE("%s %p %p\n", debugstr_w(szFolder), szPathBuf, pcchPathBuf );
 265
 266     str.unicode = TRUE;
 267     str.str.w = szPathBuf;
 268
 269     return MSI_GetSourcePath( hInstall, szFolder, &str, pcchPathBuf );
 270 }
 271
 272 /***********************************************************************
 273  * MsiSetTargetPathA  (MSI.@)
 274  */
 275 UINT WINAPI MsiSetTargetPathA(MSIHANDLE hInstall, LPCSTR szFolder,
 276                              LPCSTR szFolderPath)
 277 {
 278     LPWSTR szwFolder;
 279     LPWSTR szwFolderPath;
 280     UINT rc;
 281
 282     if (!szFolder)
 283         return ERROR_FUNCTION_FAILED;
 284     if (hInstall == 0)
 285         return ERROR_FUNCTION_FAILED;
 286
 287     szwFolder = strdupAtoW(szFolder);
 288     if (!szwFolder)
 289         return ERROR_FUNCTION_FAILED;
 290
 291     szwFolderPath = strdupAtoW(szFolderPath);
 292     if (!szwFolderPath)
 293     {
 294         msi_free(szwFolder);
 295         return ERROR_FUNCTION_FAILED;
 296     }
 297
 298     rc = MsiSetTargetPathW(hInstall, szwFolder, szwFolderPath);
 299
 300     msi_free(szwFolder);
 301     msi_free(szwFolderPath);
 302
 303     return rc;
 304 }
 305
 306 /*
 307  * Ok my original interpretation of this was wrong. And it looks like msdn has
 308  * changed a bit also. The given folder path does not have to actually already
 309  * exist, it just cannot be read only and must be a legal folder path.
 310  */
 311 UINT MSI_SetTargetPathW(MSIPACKAGE *package, LPCWSTR szFolder,
 312                              LPCWSTR szFolderPath)
 313 {
 314     DWORD attrib;
 315     LPWSTR path = NULL;
 316     LPWSTR path2 = NULL;
 317     MSIFOLDER *folder;
 318
 319     TRACE("(%p %s %s)\n",package, debugstr_w(szFolder),debugstr_w(szFolderPath));
 320
 321     if (package==NULL)
 322         return ERROR_INVALID_HANDLE;
 323
 324     if (szFolderPath[0]==0)
 325         return ERROR_FUNCTION_FAILED;
 326
 327     attrib = GetFileAttributesW(szFolderPath);
 328     if ( attrib != INVALID_FILE_ATTRIBUTES &&
 329           (!(attrib & FILE_ATTRIBUTE_DIRECTORY) ||
 330            attrib & FILE_ATTRIBUTE_OFFLINE ||
 331            attrib & FILE_ATTRIBUTE_READONLY))
 332         return ERROR_FUNCTION_FAILED;
 333
 334     path = resolve_folder(package,szFolder,FALSE,FALSE,&folder);
 335
 336     if (!path)
 337         return ERROR_INVALID_PARAMETER;
 338
 339     if (attrib == INVALID_FILE_ATTRIBUTES)
 340     {
 341         if (!CreateDirectoryW(szFolderPath,NULL))
 342             return ERROR_FUNCTION_FAILED;
 343         RemoveDirectoryW(szFolderPath);
 344     }
 345
 346     msi_free(folder->Property);
 347     folder->Property = build_directory_name(2, szFolderPath, NULL);
 348
 349     if (lstrcmpiW(path, folder->Property) == 0)
 350     {
 351         /*
 352          *  Resolved Target has not really changed, so just
 353          *  set this folder and do not recalculate everything.
 354          */
 355         msi_free(folder->ResolvedTarget);
 356         folder->ResolvedTarget = NULL;
 357         path2 = resolve_folder(package,szFolder,FALSE,TRUE,NULL);
 358         msi_free(path2);
 359     }
 360     else
 361     {
 362         MSIFOLDER *f;
 363
 364         LIST_FOR_EACH_ENTRY( f, &package->folders, MSIFOLDER, entry )
 365         {
 366             msi_free(f->ResolvedTarget);
 367             f->ResolvedTarget=NULL;
 368         }
 369
 370         LIST_FOR_EACH_ENTRY( f, &package->folders, MSIFOLDER, entry )
 371         {
 372             path2 = resolve_folder(package, f->Directory, FALSE, TRUE, NULL);
 373             msi_free(path2);
 374         }
 375     }
 376     msi_free(path);
 377
 378     return ERROR_SUCCESS;
 379 }
 380
 381 /***********************************************************************
 382  * MsiSetTargetPathW  (MSI.@)
 383  */
 384 UINT WINAPI MsiSetTargetPathW(MSIHANDLE hInstall, LPCWSTR szFolder,
 385                              LPCWSTR szFolderPath)
 386 {
 387     MSIPACKAGE *package;
 388     UINT ret;
 389
 390     TRACE("(%s %s)\n",debugstr_w(szFolder),debugstr_w(szFolderPath));
 391
 392     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 393     ret = MSI_SetTargetPathW( package, szFolder, szFolderPath );
 394     msiobj_release( &package->hdr );
 395     return ret;
 396 }
 397
 398 /***********************************************************************
 399  *           MsiGetMode    (MSI.@)
 400  *
 401  * Returns an internal installer state (if it is running in a mode iRunMode)
 402  *
 403  * PARAMS
 404  *   hInstall    [I]  Handle to the installation
 405  *   hRunMode    [I]  Checking run mode
 406  *        MSIRUNMODE_ADMIN             Administrative mode
 407  *        MSIRUNMODE_ADVERTISE         Advertisement mode
 408  *        MSIRUNMODE_MAINTENANCE       Maintenance mode
 409  *        MSIRUNMODE_ROLLBACKENABLED   Rollback is enabled
 410  *        MSIRUNMODE_LOGENABLED        Log file is writing
 411  *        MSIRUNMODE_OPERATIONS        Operations in progress??
 412  *        MSIRUNMODE_REBOOTATEND       We need to reboot after installation completed
 413  *        MSIRUNMODE_REBOOTNOW         We need to reboot to continue the installation
 414  *        MSIRUNMODE_CABINET           Files from cabinet are installed
 415  *        MSIRUNMODE_SOURCESHORTNAMES  Long names in source files is suppressed
 416  *        MSIRUNMODE_TARGETSHORTNAMES  Long names in destination files is suppressed
 417  *        MSIRUNMODE_RESERVED11        Reserved
 418  *        MSIRUNMODE_WINDOWS9X         Running under Windows95/98
 419  *        MSIRUNMODE_ZAWENABLED        Demand installation is supported
 420  *        MSIRUNMODE_RESERVED14        Reserved
 421  *        MSIRUNMODE_RESERVED15        Reserved
 422  *        MSIRUNMODE_SCHEDULED         called from install script
 423  *        MSIRUNMODE_ROLLBACK          called from rollback script
 424  *        MSIRUNMODE_COMMIT            called from commit script
 425  *
 426  * RETURNS
 427  *    In the state: TRUE
 428  *    Not in the state: FALSE
 429  *
 430  */
 431
 432 BOOL WINAPI MsiGetMode(MSIHANDLE hInstall, MSIRUNMODE iRunMode)
 433 {
 434     FIXME("STUB (iRunMode=%i)\n",iRunMode);
 435     return TRUE;
 436 }
 437
 438 /***********************************************************************
 439  * MsiSetFeatureStateA (MSI.@)
 440  *
 441  * According to the docs, when this is called it immediately recalculates
 442  * all the component states as well
 443  */
 444 UINT WINAPI MsiSetFeatureStateA(MSIHANDLE hInstall, LPCSTR szFeature,
 445                                 INSTALLSTATE iState)
 446 {
 447     LPWSTR szwFeature = NULL;
 448     UINT rc;
 449
 450     szwFeature = strdupAtoW(szFeature);
 451
 452     if (!szwFeature)
 453         return ERROR_FUNCTION_FAILED;
 454
 455     rc = MsiSetFeatureStateW(hInstall,szwFeature, iState);
 456
 457     msi_free(szwFeature);
 458
 459     return rc;
 460 }
 461
 462
 463
 464 UINT WINAPI MSI_SetFeatureStateW(MSIPACKAGE* package, LPCWSTR szFeature,
 465                                 INSTALLSTATE iState)
 466 {
 467     UINT rc = ERROR_SUCCESS;
 468     MSIFEATURE *feature, *child;
 469
 470     TRACE(" %s to %i\n",debugstr_w(szFeature), iState);
 471
 472     feature = get_loaded_feature(package,szFeature);
 473     if (!feature)
 474         return ERROR_UNKNOWN_FEATURE;
 475
 476     if (iState == INSTALLSTATE_ADVERTISED &&
 477         feature->Attributes & msidbFeatureAttributesDisallowAdvertise)
 478         return ERROR_FUNCTION_FAILED;
 479
 480     feature->ActionRequest = iState;
 481     feature->Action = iState;
 482
 483     ACTION_UpdateComponentStates(package,szFeature);
 484
 485     /* update all the features that are children of this feature */
 486     LIST_FOR_EACH_ENTRY( child, &package->features, MSIFEATURE, entry )
 487     {
 488         if (lstrcmpW(szFeature, child->Feature_Parent) == 0)
 489             MSI_SetFeatureStateW(package, child->Feature, iState);
 490     }
 491
 492     return rc;
 493 }
 494
 495 /***********************************************************************
 496  * MsiSetFeatureStateW (MSI.@)
 497  */
 498 UINT WINAPI MsiSetFeatureStateW(MSIHANDLE hInstall, LPCWSTR szFeature,
 499                                 INSTALLSTATE iState)
 500 {
 501     MSIPACKAGE* package;
 502     UINT rc = ERROR_SUCCESS;
 503
 504     TRACE(" %s to %i\n",debugstr_w(szFeature), iState);
 505
 506     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 507     if (!package)
 508         return ERROR_INVALID_HANDLE;
 509
 510     rc = MSI_SetFeatureStateW(package,szFeature,iState);
 511
 512     msiobj_release( &package->hdr );
 513     return rc;
 514 }
 515
 516 /***********************************************************************
 517 * MsiGetFeatureStateA   (MSI.@)
 518 */
 519 UINT WINAPI MsiGetFeatureStateA(MSIHANDLE hInstall, LPSTR szFeature,
 520                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
 521 {
 522     LPWSTR szwFeature = NULL;
 523     UINT rc;
 524
 525     szwFeature = strdupAtoW(szFeature);
 526
 527     rc = MsiGetFeatureStateW(hInstall,szwFeature,piInstalled, piAction);
 528
 529     msi_free( szwFeature);
 530
 531     return rc;
 532 }
 533
 534 UINT MSI_GetFeatureStateW(MSIPACKAGE *package, LPWSTR szFeature,
 535                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
 536 {
 537     MSIFEATURE *feature;
 538
 539     feature = get_loaded_feature(package,szFeature);
 540     if (!feature)
 541         return ERROR_UNKNOWN_FEATURE;
 542
 543     if (piInstalled)
 544         *piInstalled = feature->Installed;
 545
 546     if (piAction)
 547         *piAction = feature->Action;
 548
 549     TRACE("returning %i %i\n", feature->Installed, feature->Action);
 550
 551     return ERROR_SUCCESS;
 552 }
 553
 554 /***********************************************************************
 555 * MsiGetFeatureStateW   (MSI.@)
 556 */
 557 UINT WINAPI MsiGetFeatureStateW(MSIHANDLE hInstall, LPWSTR szFeature,
 558                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
 559 {
 560     MSIPACKAGE* package;
 561     UINT ret;
 562
 563     TRACE("%ld %s %p %p\n", hInstall, debugstr_w(szFeature), piInstalled,
 564 piAction);
 565
 566     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 567     if (!package)
 568         return ERROR_INVALID_HANDLE;
 569     ret = MSI_GetFeatureStateW(package, szFeature, piInstalled, piAction);
 570     msiobj_release( &package->hdr );
 571     return ret;
 572 }
 573
 574 /***********************************************************************
 575  * MsiSetComponentStateA (MSI.@)
 576  */
 577 UINT WINAPI MsiSetComponentStateA(MSIHANDLE hInstall, LPCSTR szComponent,
 578                                   INSTALLSTATE iState)
 579 {
 580     UINT rc;
 581     LPWSTR szwComponent = strdupAtoW(szComponent);
 582
 583     rc = MsiSetComponentStateW(hInstall, szwComponent, iState);
 584
 585     msi_free(szwComponent);
 586
 587     return rc;
 588 }
 589
 590 /***********************************************************************
 591  * MsiGetComponentStateA (MSI.@)
 592  */
 593 UINT WINAPI MsiGetComponentStateA(MSIHANDLE hInstall, LPSTR szComponent,
 594                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
 595 {
 596     LPWSTR szwComponent= NULL;
 597     UINT rc;
 598
 599     szwComponent= strdupAtoW(szComponent);
 600
 601     rc = MsiGetComponentStateW(hInstall,szwComponent,piInstalled, piAction);
 602
 603     msi_free( szwComponent);
 604
 605     return rc;
 606 }
 607
 608 static UINT MSI_SetComponentStateW(MSIPACKAGE *package, LPCWSTR szComponent,
 609                                    INSTALLSTATE iState)
 610 {
 611     MSICOMPONENT *comp;
 612
 613     TRACE("%p %s %d\n", package, debugstr_w(szComponent), iState);
 614
 615     comp = get_loaded_component(package, szComponent);
 616     if (!comp)
 617         return ERROR_UNKNOWN_COMPONENT;
 618
 619     comp->Installed = iState;
 620
 621     return ERROR_SUCCESS;
 622 }
 623
 624 UINT MSI_GetComponentStateW(MSIPACKAGE *package, LPWSTR szComponent,
 625                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
 626 {
 627     MSICOMPONENT *comp;
 628
 629     TRACE("%p %s %p %p\n", package, debugstr_w(szComponent),
 630            piInstalled, piAction);
 631
 632     comp = get_loaded_component(package,szComponent);
 633     if (!comp)
 634         return ERROR_UNKNOWN_COMPONENT;
 635
 636     if (piInstalled)
 637         *piInstalled = comp->Installed;
 638
 639     if (piAction)
 640         *piAction = comp->Action;
 641
 642     TRACE("states (%i, %i)\n", comp->Installed, comp->Action );
 643
 644     return ERROR_SUCCESS;
 645 }
 646
 647 /***********************************************************************
 648  * MsiSetComponentStateW (MSI.@)
 649  */
 650 UINT WINAPI MsiSetComponentStateW(MSIHANDLE hInstall, LPCWSTR szComponent,
 651                                   INSTALLSTATE iState)
 652 {
 653     MSIPACKAGE* package;
 654     UINT ret;
 655
 656     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 657     if (!package)
 658         return ERROR_INVALID_HANDLE;
 659     ret = MSI_SetComponentStateW(package, szComponent, iState);
 660     msiobj_release(&package->hdr);
 661     return ret;
 662 }
 663
 664 /***********************************************************************
 665  * MsiGetComponentStateW (MSI.@)
 666  */
 667 UINT WINAPI MsiGetComponentStateW(MSIHANDLE hInstall, LPWSTR szComponent,
 668                   INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
 669 {
 670     MSIPACKAGE* package;
 671     UINT ret;
 672
 673     TRACE("%ld %s %p %p\n", hInstall, debugstr_w(szComponent),
 674            piInstalled, piAction);
 675
 676     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 677     if (!package)
 678         return ERROR_INVALID_HANDLE;
 679     ret = MSI_GetComponentStateW( package, szComponent, piInstalled, piAction);
 680     msiobj_release( &package->hdr );
 681     return ret;
 682 }
 683
 684 /***********************************************************************
 685  * MsiGetLanguage (MSI.@)
 686  */
 687 LANGID WINAPI MsiGetLanguage(MSIHANDLE hInstall)
 688 {
 689     MSIPACKAGE* package;
 690     LANGID langid;
 691     LPWSTR buffer;
 692     static const WCHAR szProductLanguage[] =
 693         {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
 694
 695     package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
 696     if (!package)
 697         return ERROR_INVALID_HANDLE;
 698
 699     buffer = msi_dup_property( package, szProductLanguage );
 700     langid = atoiW(buffer);
 701
 702     msi_free(buffer);
 703     msiobj_release (&package->hdr);
 704     return langid;
 705 }