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