git.oblomov.eu Git - wine/blob - dlls/msi/action.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2004,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 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winerror.h"
  28 #include "winreg.h"
  29 #include "winsvc.h"
  30 #include "odbcinst.h"
  31 #include "wine/debug.h"
  32 #include "msidefs.h"
  33 #include "msipriv.h"
  34 #include "winuser.h"
  35 #include "shlobj.h"
  36 #include "objbase.h"
  37 #include "mscoree.h"
  38 #include "shlwapi.h"
  39 #include "wine/unicode.h"
  40 #include "winver.h"
  41
  42 #define REG_PROGRESS_VALUE 13200
  43 #define COMPONENT_PROGRESS_VALUE 24000
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  46
  47 /*
  48  * consts and values used
  49  */
  50 static const WCHAR c_colon[] = {'C',':','\\',0};
  51
  52 static const WCHAR szCreateFolders[] =
  53     {'C','r','e','a','t','e','F','o','l','d','e','r','s',0};
  54 static const WCHAR szCostFinalize[] =
  55     {'C','o','s','t','F','i','n','a','l','i','z','e',0};
  56 static const WCHAR szWriteRegistryValues[] =
  57     {'W','r','i','t','e','R','e','g','i','s','t','r','y','V','a','l','u','e','s',0};
  58 static const WCHAR szCostInitialize[] =
  59     {'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0};
  60 static const WCHAR szFileCost[] =
  61     {'F','i','l','e','C','o','s','t',0};
  62 static const WCHAR szInstallInitialize[] =
  63     {'I','n','s','t','a','l','l','I','n','i','t','i','a','l','i','z','e',0};
  64 static const WCHAR szInstallValidate[] =
  65     {'I','n','s','t','a','l','l','V','a','l','i','d','a','t','e',0};
  66 static const WCHAR szLaunchConditions[] =
  67     {'L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','s',0};
  68 static const WCHAR szProcessComponents[] =
  69     {'P','r','o','c','e','s','s','C','o','m','p','o','n','e','n','t','s',0};
  70 static const WCHAR szRegisterTypeLibraries[] =
  71     {'R','e','g','i','s','t','e','r','T','y','p','e','L','i','b','r','a','r','i','e','s',0};
  72 static const WCHAR szCreateShortcuts[] =
  73     {'C','r','e','a','t','e','S','h','o','r','t','c','u','t','s',0};
  74 static const WCHAR szPublishProduct[] =
  75     {'P','u','b','l','i','s','h','P','r','o','d','u','c','t',0};
  76 static const WCHAR szWriteIniValues[] =
  77     {'W','r','i','t','e','I','n','i','V','a','l','u','e','s',0};
  78 static const WCHAR szSelfRegModules[] =
  79     {'S','e','l','f','R','e','g','M','o','d','u','l','e','s',0};
  80 static const WCHAR szPublishFeatures[] =
  81     {'P','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
  82 static const WCHAR szRegisterProduct[] =
  83     {'R','e','g','i','s','t','e','r','P','r','o','d','u','c','t',0};
  84 static const WCHAR szInstallExecute[] =
  85     {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',0};
  86 static const WCHAR szInstallExecuteAgain[] =
  87     {'I','n','s','t','a','l','l','E','x','e','c','u','t','e','A','g','a','i','n',0};
  88 static const WCHAR szInstallFinalize[] =
  89     {'I','n','s','t','a','l','l','F','i','n','a','l','i','z','e',0};
  90 static const WCHAR szForceReboot[] =
  91     {'F','o','r','c','e','R','e','b','o','o','t',0};
  92 static const WCHAR szResolveSource[] =
  93     {'R','e','s','o','l','v','e','S','o','u','r','c','e',0};
  94 static const WCHAR szAllocateRegistrySpace[] =
  95     {'A','l','l','o','c','a','t','e','R','e','g','i','s','t','r','y','S','p','a','c','e',0};
  96 static const WCHAR szBindImage[] =
  97     {'B','i','n','d','I','m','a','g','e',0};
  98 static const WCHAR szDeleteServices[] =
  99     {'D','e','l','e','t','e','S','e','r','v','i','c','e','s',0};
 100 static const WCHAR szDisableRollback[] =
 101     {'D','i','s','a','b','l','e','R','o','l','l','b','a','c','k',0};
 102 static const WCHAR szExecuteAction[] =
 103     {'E','x','e','c','u','t','e','A','c','t','i','o','n',0};
 104 static const WCHAR szInstallAdminPackage[] =
 105     {'I','n','s','t','a','l','l','A','d','m','i','n','P','a','c','k','a','g','e',0};
 106 static const WCHAR szInstallSFPCatalogFile[] =
 107     {'I','n','s','t','a','l','l','S','F','P','C','a','t','a','l','o','g','F','i','l','e',0};
 108 static const WCHAR szIsolateComponents[] =
 109     {'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t','s',0};
 110 static const WCHAR szMigrateFeatureStates[] =
 111     {'M','i','g','r','a','t','e','F','e','a','t','u','r','e','S','t','a','t','e','s',0};
 112 static const WCHAR szMsiUnpublishAssemblies[] =
 113     {'M','s','i','U','n','p','u','b','l','i','s','h','A','s','s','e','m','b','l','i','e','s',0};
 114 static const WCHAR szInstallODBC[] =
 115     {'I','n','s','t','a','l','l','O','D','B','C',0};
 116 static const WCHAR szInstallServices[] =
 117     {'I','n','s','t','a','l','l','S','e','r','v','i','c','e','s',0};
 118 static const WCHAR szPatchFiles[] =
 119     {'P','a','t','c','h','F','i','l','e','s',0};
 120 static const WCHAR szPublishComponents[] =
 121     {'P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t','s',0};
 122 static const WCHAR szRegisterComPlus[] =
 123     {'R','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
 124 static const WCHAR szRegisterUser[] =
 125     {'R','e','g','i','s','t','e','r','U','s','e','r',0};
 126 static const WCHAR szRemoveEnvironmentStrings[] =
 127     {'R','e','m','o','v','e','E','n','v','i','r','o','n','m','e','n','t','S','t','r','i','n','g','s',0};
 128 static const WCHAR szRemoveExistingProducts[] =
 129     {'R','e','m','o','v','e','E','x','i','s','t','i','n','g','P','r','o','d','u','c','t','s',0};
 130 static const WCHAR szRemoveFolders[] =
 131     {'R','e','m','o','v','e','F','o','l','d','e','r','s',0};
 132 static const WCHAR szRemoveIniValues[] =
 133     {'R','e','m','o','v','e','I','n','i','V','a','l','u','e','s',0};
 134 static const WCHAR szRemoveODBC[] =
 135     {'R','e','m','o','v','e','O','D','B','C',0};
 136 static const WCHAR szRemoveRegistryValues[] =
 137     {'R','e','m','o','v','e','R','e','g','i','s','t','r','y','V','a','l','u','e','s',0};
 138 static const WCHAR szRemoveShortcuts[] =
 139     {'R','e','m','o','v','e','S','h','o','r','t','c','u','t','s',0};
 140 static const WCHAR szRMCCPSearch[] =
 141     {'R','M','C','C','P','S','e','a','r','c','h',0};
 142 static const WCHAR szScheduleReboot[] =
 143     {'S','c','h','e','d','u','l','e','R','e','b','o','o','t',0};
 144 static const WCHAR szSelfUnregModules[] =
 145     {'S','e','l','f','U','n','r','e','g','M','o','d','u','l','e','s',0};
 146 static const WCHAR szSetODBCFolders[] =
 147     {'S','e','t','O','D','B','C','F','o','l','d','e','r','s',0};
 148 static const WCHAR szStartServices[] =
 149     {'S','t','a','r','t','S','e','r','v','i','c','e','s',0};
 150 static const WCHAR szStopServices[] =
 151     {'S','t','o','p','S','e','r','v','i','c','e','s',0};
 152 static const WCHAR szUnpublishComponents[] =
 153     {'U','n','p','u','b','l','i','s','h', 'C','o','m','p','o','n','e','n','t','s',0};
 154 static const WCHAR szUnpublishFeatures[] =
 155     {'U','n','p','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
 156 static const WCHAR szUnregisterComPlus[] =
 157     {'U','n','r','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
 158 static const WCHAR szUnregisterTypeLibraries[] =
 159     {'U','n','r','e','g','i','s','t','e','r','T','y','p','e','L','i','b','r','a','r','i','e','s',0};
 160 static const WCHAR szValidateProductID[] =
 161     {'V','a','l','i','d','a','t','e','P','r','o','d','u','c','t','I','D',0};
 162 static const WCHAR szWriteEnvironmentStrings[] =
 163     {'W','r','i','t','e','E','n','v','i','r','o','n','m','e','n','t','S','t','r','i','n','g','s',0};
 164
 165 /********************************************************
 166  * helper functions
 167  ********************************************************/
 168
 169 void msi_feature_set_state( MSIPACKAGE *package, MSIFEATURE *feature, INSTALLSTATE state )
 170 {
 171     if (!package->ProductCode)
 172     {
 173         feature->ActionRequest = state;
 174         feature->Action = state;
 175     }
 176     else if (state == INSTALLSTATE_ABSENT)
 177     {
 178         switch (feature->Installed)
 179         {
 180             case INSTALLSTATE_ABSENT:
 181                 feature->ActionRequest = INSTALLSTATE_UNKNOWN;
 182                 feature->Action = INSTALLSTATE_UNKNOWN;
 183                 break;
 184             default:
 185                 feature->ActionRequest = state;
 186                 feature->Action = state;
 187         }
 188     }
 189     else if (state == INSTALLSTATE_SOURCE)
 190     {
 191         switch (feature->Installed)
 192         {
 193             case INSTALLSTATE_ABSENT:
 194             case INSTALLSTATE_SOURCE:
 195                 feature->ActionRequest = state;
 196                 feature->Action = state;
 197                 break;
 198             case INSTALLSTATE_LOCAL:
 199                 feature->ActionRequest = INSTALLSTATE_LOCAL;
 200                 feature->Action = INSTALLSTATE_LOCAL;
 201                 break;
 202             default:
 203                 feature->ActionRequest = INSTALLSTATE_UNKNOWN;
 204                 feature->Action = INSTALLSTATE_UNKNOWN;
 205         }
 206     }
 207     else
 208     {
 209         feature->ActionRequest = state;
 210         feature->Action = state;
 211     }
 212 }
 213
 214 void msi_component_set_state( MSIPACKAGE *package, MSICOMPONENT *comp, INSTALLSTATE state )
 215 {
 216     if (!package->ProductCode)
 217     {
 218         comp->ActionRequest = state;
 219         comp->Action = state;
 220     }
 221     else if (state == INSTALLSTATE_ABSENT)
 222     {
 223         switch (comp->Installed)
 224         {
 225             case INSTALLSTATE_LOCAL:
 226             case INSTALLSTATE_SOURCE:
 227             case INSTALLSTATE_DEFAULT:
 228                 comp->ActionRequest = state;
 229                 comp->Action = state;
 230                 break;
 231             default:
 232                 comp->ActionRequest = INSTALLSTATE_UNKNOWN;
 233                 comp->Action = INSTALLSTATE_UNKNOWN;
 234         }
 235     }
 236     else if (state == INSTALLSTATE_SOURCE)
 237     {
 238         if (comp->Installed == INSTALLSTATE_ABSENT ||
 239             (comp->Installed == INSTALLSTATE_SOURCE && comp->hasLocalFeature))
 240         {
 241             comp->ActionRequest = state;
 242             comp->Action = state;
 243         }
 244         else
 245         {
 246             comp->ActionRequest = INSTALLSTATE_UNKNOWN;
 247             comp->Action = INSTALLSTATE_UNKNOWN;
 248         }
 249     }
 250     else
 251     {
 252         comp->ActionRequest = state;
 253         comp->Action = state;
 254     }
 255 }
 256
 257 static void ui_actionstart(MSIPACKAGE *package, LPCWSTR action)
 258 {
 259     static const WCHAR Query_t[] =
 260         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 261          '`','A','c','t','i','o', 'n','T','e','x','t','`',' ',
 262          'W','H','E','R','E', ' ','`','A','c','t','i','o','n','`',' ','=',
 263          ' ','\'','%','s','\'',0};
 264     MSIRECORD * row;
 265
 266     row = MSI_QueryGetRecord( package->db, Query_t, action );
 267     if (!row)
 268         return;
 269     MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, row);
 270     msiobj_release(&row->hdr);
 271 }
 272
 273 static void ui_actioninfo(MSIPACKAGE *package, LPCWSTR action, BOOL start,
 274                           UINT rc)
 275 {
 276     MSIRECORD * row;
 277     static const WCHAR template_s[]=
 278         {'A','c','t','i','o','n',' ','s','t','a','r','t',' ','%','s',':',' ',
 279          '%','s', '.',0};
 280     static const WCHAR template_e[]=
 281         {'A','c','t','i','o','n',' ','e','n','d','e','d',' ','%','s',':',' ',
 282          '%','s', '.',' ','R','e','t','u','r','n',' ','v','a','l','u','e',' ',
 283          '%','i','.',0};
 284     static const WCHAR format[] =
 285         {'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0};
 286     WCHAR message[1024];
 287     WCHAR timet[0x100];
 288
 289     GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, format, timet, 0x100);
 290     if (start)
 291         sprintfW(message,template_s,timet,action);
 292     else
 293         sprintfW(message,template_e,timet,action,rc);
 294
 295     row = MSI_CreateRecord(1);
 296     MSI_RecordSetStringW(row,1,message);
 297
 298     MSI_ProcessMessage(package, INSTALLMESSAGE_INFO, row);
 299     msiobj_release(&row->hdr);
 300 }
 301
 302 UINT msi_parse_command_line( MSIPACKAGE *package, LPCWSTR szCommandLine,
 303                              BOOL preserve_case )
 304 {
 305     LPCWSTR ptr,ptr2;
 306     BOOL quote;
 307     DWORD len;
 308     LPWSTR prop = NULL, val = NULL;
 309
 310     if (!szCommandLine)
 311         return ERROR_SUCCESS;
 312
 313     ptr = szCommandLine;
 314
 315     while (*ptr)
 316     {
 317         if (*ptr==' ')
 318         {
 319             ptr++;
 320             continue;
 321         }
 322
 323         TRACE("Looking at %s\n",debugstr_w(ptr));
 324
 325         ptr2 = strchrW(ptr,'=');
 326         if (!ptr2)
 327         {
 328             ERR("command line contains unknown string : %s\n", debugstr_w(ptr));
 329             break;
 330         }
 331
 332         quote = FALSE;
 333
 334         len = ptr2-ptr;
 335         prop = msi_alloc((len+1)*sizeof(WCHAR));
 336         memcpy(prop,ptr,len*sizeof(WCHAR));
 337         prop[len]=0;
 338
 339         if (!preserve_case)
 340             struprW(prop);
 341
 342         ptr2++;
 343
 344         len = 0;
 345         ptr = ptr2;
 346         while (*ptr && (quote || (!quote && *ptr!=' ')))
 347         {
 348             if (*ptr == '"')
 349                 quote = !quote;
 350             ptr++;
 351             len++;
 352         }
 353
 354         if (*ptr2=='"')
 355         {
 356             ptr2++;
 357             len -= 2;
 358         }
 359         val = msi_alloc((len+1)*sizeof(WCHAR));
 360         memcpy(val,ptr2,len*sizeof(WCHAR));
 361         val[len] = 0;
 362
 363         if (lstrlenW(prop) > 0)
 364         {
 365             UINT r = msi_set_property( package->db, prop, val );
 366
 367             TRACE("Found commandline property (%s) = (%s)\n",
 368                    debugstr_w(prop), debugstr_w(val));
 369
 370             if (r == ERROR_SUCCESS && !strcmpW( prop, cszSourceDir ))
 371                 msi_reset_folders( package, TRUE );
 372         }
 373         msi_free(val);
 374         msi_free(prop);
 375     }
 376
 377     return ERROR_SUCCESS;
 378 }
 379
 380
 381 static LPWSTR* msi_split_string( LPCWSTR str, WCHAR sep )
 382 {
 383     LPCWSTR pc;
 384     LPWSTR p, *ret = NULL;
 385     UINT count = 0;
 386
 387     if (!str)
 388         return ret;
 389
 390     /* count the number of substrings */
 391     for ( pc = str, count = 0; pc; count++ )
 392     {
 393         pc = strchrW( pc, sep );
 394         if (pc)
 395             pc++;
 396     }
 397
 398     /* allocate space for an array of substring pointers and the substrings */
 399     ret = msi_alloc( (count+1) * sizeof (LPWSTR) +
 400                      (lstrlenW(str)+1) * sizeof(WCHAR) );
 401     if (!ret)
 402         return ret;
 403
 404     /* copy the string and set the pointers */
 405     p = (LPWSTR) &ret[count+1];
 406     lstrcpyW( p, str );
 407     for( count = 0; (ret[count] = p); count++ )
 408     {
 409         p = strchrW( p, sep );
 410         if (p)
 411             *p++ = 0;
 412     }
 413
 414     return ret;
 415 }
 416
 417 static UINT msi_check_transform_applicable( MSIPACKAGE *package, IStorage *patch )
 418 {
 419     static const WCHAR szSystemLanguageID[] =
 420         { 'S','y','s','t','e','m','L','a','n','g','u','a','g','e','I','D',0 };
 421
 422     LPWSTR prod_code, patch_product, langid = NULL, template = NULL;
 423     UINT ret = ERROR_FUNCTION_FAILED;
 424
 425     prod_code = msi_dup_property( package->db, szProductCode );
 426     patch_product = msi_get_suminfo_product( patch );
 427
 428     TRACE("db = %s patch = %s\n", debugstr_w(prod_code), debugstr_w(patch_product));
 429
 430     if ( strstrW( patch_product, prod_code ) )
 431     {
 432         MSISUMMARYINFO *si;
 433         const WCHAR *p;
 434
 435         si = MSI_GetSummaryInformationW( patch, 0 );
 436         if (!si)
 437         {
 438             ERR("no summary information!\n");
 439             goto end;
 440         }
 441
 442         template = msi_suminfo_dup_string( si, PID_TEMPLATE );
 443         if (!template)
 444         {
 445             ERR("no template property!\n");
 446             msiobj_release( &si->hdr );
 447             goto end;
 448         }
 449
 450         if (!template[0])
 451         {
 452             ret = ERROR_SUCCESS;
 453             msiobj_release( &si->hdr );
 454             goto end;
 455         }
 456
 457         langid = msi_dup_property( package->db, szSystemLanguageID );
 458         if (!langid)
 459         {
 460             msiobj_release( &si->hdr );
 461             goto end;
 462         }
 463
 464         p = strchrW( template, ';' );
 465         if (p && (!strcmpW( p + 1, langid ) || !strcmpW( p + 1, szZero )))
 466         {
 467             TRACE("applicable transform\n");
 468             ret = ERROR_SUCCESS;
 469         }
 470
 471         /* FIXME: check platform */
 472
 473         msiobj_release( &si->hdr );
 474     }
 475
 476 end:
 477     msi_free( patch_product );
 478     msi_free( prod_code );
 479     msi_free( template );
 480     msi_free( langid );
 481
 482     return ret;
 483 }
 484
 485 static UINT msi_apply_substorage_transform( MSIPACKAGE *package,
 486                                  MSIDATABASE *patch_db, LPCWSTR name )
 487 {
 488     UINT ret = ERROR_FUNCTION_FAILED;
 489     IStorage *stg = NULL;
 490     HRESULT r;
 491
 492     TRACE("%p %s\n", package, debugstr_w(name) );
 493
 494     if (*name++ != ':')
 495     {
 496         ERR("expected a colon in %s\n", debugstr_w(name));
 497         return ERROR_FUNCTION_FAILED;
 498     }
 499
 500     r = IStorage_OpenStorage( patch_db->storage, name, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg );
 501     if (SUCCEEDED(r))
 502     {
 503         ret = msi_check_transform_applicable( package, stg );
 504         if (ret == ERROR_SUCCESS)
 505             msi_table_apply_transform( package->db, stg );
 506         else
 507             TRACE("substorage transform %s wasn't applicable\n", debugstr_w(name));
 508         IStorage_Release( stg );
 509     }
 510     else
 511         ERR("failed to open substorage %s\n", debugstr_w(name));
 512
 513     return ERROR_SUCCESS;
 514 }
 515
 516 UINT msi_check_patch_applicable( MSIPACKAGE *package, MSISUMMARYINFO *si )
 517 {
 518     LPWSTR guid_list, *guids, product_code;
 519     UINT i, ret = ERROR_FUNCTION_FAILED;
 520
 521     product_code = msi_dup_property( package->db, szProductCode );
 522     if (!product_code)
 523     {
 524         /* FIXME: the property ProductCode should be written into the DB somewhere */
 525         ERR("no product code to check\n");
 526         return ERROR_SUCCESS;
 527     }
 528
 529     guid_list = msi_suminfo_dup_string( si, PID_TEMPLATE );
 530     guids = msi_split_string( guid_list, ';' );
 531     for ( i = 0; guids[i] && ret != ERROR_SUCCESS; i++ )
 532     {
 533         if (!strcmpW( guids[i], product_code ))
 534             ret = ERROR_SUCCESS;
 535     }
 536     msi_free( guids );
 537     msi_free( guid_list );
 538     msi_free( product_code );
 539
 540     return ret;
 541 }
 542
 543 static UINT msi_set_media_source_prop(MSIPACKAGE *package)
 544 {
 545     MSIQUERY *view;
 546     MSIRECORD *rec = NULL;
 547     LPWSTR patch;
 548     LPCWSTR prop;
 549     UINT r;
 550
 551     static const WCHAR query[] = {'S','E','L','E','C','T',' ',
 552         '`','S','o','u','r','c','e','`',' ','F','R','O','M',' ',
 553         '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
 554         '`','S','o','u','r','c','e','`',' ','I','S',' ',
 555         'N','O','T',' ','N','U','L','L',0};
 556
 557     r = MSI_DatabaseOpenViewW(package->db, query, &view);
 558     if (r != ERROR_SUCCESS)
 559         return r;
 560
 561     r = MSI_ViewExecute(view, 0);
 562     if (r != ERROR_SUCCESS)
 563         goto done;
 564
 565     if (MSI_ViewFetch(view, &rec) == ERROR_SUCCESS)
 566     {
 567         prop = MSI_RecordGetString(rec, 1);
 568         patch = msi_dup_property(package->db, szPatch);
 569         msi_set_property(package->db, prop, patch);
 570         msi_free(patch);
 571     }
 572
 573 done:
 574     if (rec) msiobj_release(&rec->hdr);
 575     msiobj_release(&view->hdr);
 576
 577     return r;
 578 }
 579
 580 UINT msi_parse_patch_summary( MSISUMMARYINFO *si, MSIPATCHINFO **patch )
 581 {
 582     MSIPATCHINFO *pi;
 583     UINT r = ERROR_SUCCESS;
 584     WCHAR *p;
 585
 586     pi = msi_alloc_zero( sizeof(MSIPATCHINFO) );
 587     if (!pi)
 588         return ERROR_OUTOFMEMORY;
 589
 590     pi->patchcode = msi_suminfo_dup_string( si, PID_REVNUMBER );
 591     if (!pi->patchcode)
 592     {
 593         msi_free( pi );
 594         return ERROR_OUTOFMEMORY;
 595     }
 596
 597     p = pi->patchcode;
 598     if (*p != '{')
 599     {
 600         msi_free( pi->patchcode );
 601         msi_free( pi );
 602         return ERROR_PATCH_PACKAGE_INVALID;
 603     }
 604
 605     p = strchrW( p + 1, '}' );
 606     if (!p)
 607     {
 608         msi_free( pi->patchcode );
 609         msi_free( pi );
 610         return ERROR_PATCH_PACKAGE_INVALID;
 611     }
 612
 613     if (p[1])
 614     {
 615         FIXME("patch obsoletes %s\n", debugstr_w(p + 1));
 616         p[1] = 0;
 617     }
 618
 619     TRACE("patch code %s\n", debugstr_w(pi->patchcode));
 620
 621     pi->transforms = msi_suminfo_dup_string( si, PID_LASTAUTHOR );
 622     if (!pi->transforms)
 623     {
 624         msi_free( pi->patchcode );
 625         msi_free( pi );
 626         return ERROR_OUTOFMEMORY;
 627     }
 628
 629     *patch = pi;
 630     return r;
 631 }
 632
 633 UINT msi_apply_patch_db( MSIPACKAGE *package, MSIDATABASE *patch_db, MSIPATCHINFO *patch )
 634 {
 635     UINT i, r = ERROR_SUCCESS;
 636     WCHAR **substorage;
 637
 638     /* apply substorage transforms */
 639     substorage = msi_split_string( patch->transforms, ';' );
 640     for (i = 0; substorage && substorage[i] && r == ERROR_SUCCESS; i++)
 641         r = msi_apply_substorage_transform( package, patch_db, substorage[i] );
 642
 643     msi_free( substorage );
 644     if (r != ERROR_SUCCESS)
 645         return r;
 646
 647     msi_set_media_source_prop( package );
 648
 649     /*
 650      * There might be a CAB file in the patch package,
 651      * so append it to the list of storages to search for streams.
 652      */
 653     append_storage_to_db( package->db, patch_db->storage );
 654
 655     patch->state = MSIPATCHSTATE_APPLIED;
 656     list_add_tail( &package->patches, &patch->entry );
 657     return ERROR_SUCCESS;
 658 }
 659
 660 static UINT msi_apply_patch_package( MSIPACKAGE *package, LPCWSTR file )
 661 {
 662     static const WCHAR dotmsp[] = {'.','m','s','p',0};
 663     MSIDATABASE *patch_db = NULL;
 664     WCHAR localfile[MAX_PATH];
 665     MSISUMMARYINFO *si;
 666     MSIPATCHINFO *patch = NULL;
 667     UINT r = ERROR_SUCCESS;
 668
 669     TRACE("%p %s\n", package, debugstr_w( file ) );
 670
 671     r = MSI_OpenDatabaseW( file, MSIDBOPEN_READONLY + MSIDBOPEN_PATCHFILE, &patch_db );
 672     if ( r != ERROR_SUCCESS )
 673     {
 674         ERR("failed to open patch collection %s\n", debugstr_w( file ) );
 675         return r;
 676     }
 677
 678     si = MSI_GetSummaryInformationW( patch_db->storage, 0 );
 679     if (!si)
 680     {
 681         msiobj_release( &patch_db->hdr );
 682         return ERROR_FUNCTION_FAILED;
 683     }
 684
 685     r = msi_check_patch_applicable( package, si );
 686     if (r != ERROR_SUCCESS)
 687     {
 688         TRACE("patch not applicable\n");
 689         r = ERROR_SUCCESS;
 690         goto done;
 691     }
 692
 693     r = msi_parse_patch_summary( si, &patch );
 694     if ( r != ERROR_SUCCESS )
 695         goto done;
 696
 697     r = msi_get_local_package_name( localfile, dotmsp );
 698     if ( r != ERROR_SUCCESS )
 699         goto done;
 700
 701     TRACE("copying to local package %s\n", debugstr_w(localfile));
 702
 703     if (!CopyFileW( file, localfile, FALSE ))
 704     {
 705         ERR("Unable to copy package (%s -> %s) (error %u)\n",
 706             debugstr_w(file), debugstr_w(localfile), GetLastError());
 707         r = GetLastError();
 708         goto done;
 709     }
 710     patch->localfile = strdupW( localfile );
 711
 712     r = msi_apply_patch_db( package, patch_db, patch );
 713     if ( r != ERROR_SUCCESS )
 714         WARN("patch failed to apply %u\n", r);
 715
 716 done:
 717     msiobj_release( &si->hdr );
 718     msiobj_release( &patch_db->hdr );
 719     if (patch && r != ERROR_SUCCESS)
 720     {
 721         if (patch->localfile)
 722             DeleteFileW( patch->localfile );
 723
 724         msi_free( patch->patchcode );
 725         msi_free( patch->transforms );
 726         msi_free( patch->localfile );
 727         msi_free( patch );
 728     }
 729     return r;
 730 }
 731
 732 /* get the PATCH property, and apply all the patches it specifies */
 733 static UINT msi_apply_patches( MSIPACKAGE *package )
 734 {
 735     LPWSTR patch_list, *patches;
 736     UINT i, r = ERROR_SUCCESS;
 737
 738     patch_list = msi_dup_property( package->db, szPatch );
 739
 740     TRACE("patches to be applied: %s\n", debugstr_w( patch_list ) );
 741
 742     patches = msi_split_string( patch_list, ';' );
 743     for( i=0; patches && patches[i] && r == ERROR_SUCCESS; i++ )
 744         r = msi_apply_patch_package( package, patches[i] );
 745
 746     msi_free( patches );
 747     msi_free( patch_list );
 748
 749     return r;
 750 }
 751
 752 static UINT msi_apply_transforms( MSIPACKAGE *package )
 753 {
 754     static const WCHAR szTransforms[] = {
 755         'T','R','A','N','S','F','O','R','M','S',0 };
 756     LPWSTR xform_list, *xforms;
 757     UINT i, r = ERROR_SUCCESS;
 758
 759     xform_list = msi_dup_property( package->db, szTransforms );
 760     xforms = msi_split_string( xform_list, ';' );
 761
 762     for( i=0; xforms && xforms[i] && r == ERROR_SUCCESS; i++ )
 763     {
 764         if (xforms[i][0] == ':')
 765             r = msi_apply_substorage_transform( package, package->db, xforms[i] );
 766         else
 767             r = MSI_DatabaseApplyTransformW( package->db, xforms[i], 0 );
 768     }
 769
 770     msi_free( xforms );
 771     msi_free( xform_list );
 772
 773     return r;
 774 }
 775
 776 static BOOL ui_sequence_exists( MSIPACKAGE *package )
 777 {
 778     MSIQUERY *view;
 779     UINT rc;
 780
 781     static const WCHAR ExecSeqQuery [] =
 782         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 783          '`','I','n','s','t','a','l','l',
 784          'U','I','S','e','q','u','e','n','c','e','`',
 785          ' ','W','H','E','R','E',' ',
 786          '`','S','e','q','u','e','n','c','e','`',' ',
 787          '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
 788          '`','S','e','q','u','e','n','c','e','`',0};
 789
 790     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 791     if (rc == ERROR_SUCCESS)
 792     {
 793         msiobj_release(&view->hdr);
 794         return TRUE;
 795     }
 796
 797     return FALSE;
 798 }
 799
 800 UINT msi_set_sourcedir_props(MSIPACKAGE *package, BOOL replace)
 801 {
 802     LPWSTR source, check;
 803
 804     if (msi_get_property_int( package->db, szInstalled, 0 ))
 805     {
 806         HKEY hkey;
 807
 808         MSIREG_OpenInstallProps( package->ProductCode, package->Context, NULL, &hkey, FALSE );
 809         source = msi_reg_get_val_str( hkey, INSTALLPROPERTY_INSTALLSOURCEW );
 810         RegCloseKey( hkey );
 811     }
 812     else
 813     {
 814         LPWSTR p, db;
 815         DWORD len;
 816
 817         db = msi_dup_property( package->db, szOriginalDatabase );
 818         if (!db)
 819             return ERROR_OUTOFMEMORY;
 820
 821         p = strrchrW( db, '\\' );
 822         if (!p)
 823         {
 824             p = strrchrW( db, '/' );
 825             if (!p)
 826             {
 827                 msi_free(db);
 828                 return ERROR_SUCCESS;
 829             }
 830         }
 831
 832         len = p - db + 2;
 833         source = msi_alloc( len * sizeof(WCHAR) );
 834         lstrcpynW( source, db, len );
 835         msi_free( db );
 836     }
 837
 838     check = msi_dup_property( package->db, cszSourceDir );
 839     if (!check || replace)
 840     {
 841         UINT r = msi_set_property( package->db, cszSourceDir, source );
 842         if (r == ERROR_SUCCESS)
 843             msi_reset_folders( package, TRUE );
 844     }
 845     msi_free( check );
 846
 847     check = msi_dup_property( package->db, cszSOURCEDIR );
 848     if (!check || replace)
 849         msi_set_property( package->db, cszSOURCEDIR, source );
 850
 851     msi_free( check );
 852     msi_free( source );
 853
 854     return ERROR_SUCCESS;
 855 }
 856
 857 static BOOL needs_ui_sequence(MSIPACKAGE *package)
 858 {
 859     INT level = msi_get_property_int(package->db, szUILevel, 0);
 860     return (level & INSTALLUILEVEL_MASK) >= INSTALLUILEVEL_REDUCED;
 861 }
 862
 863 UINT msi_set_context(MSIPACKAGE *package)
 864 {
 865     int num;
 866
 867     package->Context = MSIINSTALLCONTEXT_USERUNMANAGED;
 868
 869     num = msi_get_property_int(package->db, szAllUsers, 0);
 870     if (num == 1 || num == 2)
 871         package->Context = MSIINSTALLCONTEXT_MACHINE;
 872
 873     return ERROR_SUCCESS;
 874 }
 875
 876 static UINT ITERATE_Actions(MSIRECORD *row, LPVOID param)
 877 {
 878     UINT rc;
 879     LPCWSTR cond, action;
 880     MSIPACKAGE *package = param;
 881
 882     action = MSI_RecordGetString(row,1);
 883     if (!action)
 884     {
 885         ERR("Error is retrieving action name\n");
 886         return ERROR_FUNCTION_FAILED;
 887     }
 888
 889     /* check conditions */
 890     cond = MSI_RecordGetString(row,2);
 891
 892     /* this is a hack to skip errors in the condition code */
 893     if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
 894     {
 895         TRACE("Skipping action: %s (condition is false)\n", debugstr_w(action));
 896         return ERROR_SUCCESS;
 897     }
 898
 899     if (needs_ui_sequence(package))
 900         rc = ACTION_PerformUIAction(package, action, -1);
 901     else
 902         rc = ACTION_PerformAction(package, action, -1);
 903
 904     msi_dialog_check_messages( NULL );
 905
 906     if (package->CurrentInstallState != ERROR_SUCCESS)
 907         rc = package->CurrentInstallState;
 908
 909     if (rc == ERROR_FUNCTION_NOT_CALLED)
 910         rc = ERROR_SUCCESS;
 911
 912     if (rc != ERROR_SUCCESS)
 913         ERR("Execution halted, action %s returned %i\n", debugstr_w(action), rc);
 914
 915     return rc;
 916 }
 917
 918 UINT MSI_Sequence( MSIPACKAGE *package, LPCWSTR szTable, INT iSequenceMode )
 919 {
 920     MSIQUERY * view;
 921     UINT r;
 922     static const WCHAR query[] =
 923         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 924          '`','%','s','`',
 925          ' ','W','H','E','R','E',' ',
 926          '`','S','e','q','u','e','n','c','e','`',' ',
 927          '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
 928          '`','S','e','q','u','e','n','c','e','`',0};
 929
 930     TRACE("%p %s %i\n", package, debugstr_w(szTable), iSequenceMode );
 931
 932     r = MSI_OpenQuery( package->db, &view, query, szTable );
 933     if (r == ERROR_SUCCESS)
 934     {
 935         r = MSI_IterateRecords( view, NULL, ITERATE_Actions, package );
 936         msiobj_release(&view->hdr);
 937     }
 938
 939     return r;
 940 }
 941
 942 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran)
 943 {
 944     MSIQUERY * view;
 945     UINT rc;
 946     static const WCHAR ExecSeqQuery[] =
 947         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
 948          '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
 949          'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
 950          '`','S','e','q','u','e','n','c','e','`',' ', '>',' ','%','i',' ',
 951          'O','R','D','E','R',' ', 'B','Y',' ',
 952          '`','S','e','q','u','e','n','c','e','`',0 };
 953     static const WCHAR IVQuery[] =
 954         {'S','E','L','E','C','T',' ','`','S','e','q','u','e','n','c','e','`',
 955          ' ', 'F','R','O','M',' ','`','I','n','s','t','a','l','l',
 956          'E','x','e','c','u','t','e','S','e','q','u','e','n','c','e','`',' ',
 957          'W','H','E','R','E',' ','`','A','c','t','i','o','n','`',' ','=',
 958          ' ','\'', 'I','n','s','t','a','l','l',
 959          'V','a','l','i','d','a','t','e','\'', 0};
 960     INT seq = 0;
 961
 962     if (package->script->ExecuteSequenceRun)
 963     {
 964         TRACE("Execute Sequence already Run\n");
 965         return ERROR_SUCCESS;
 966     }
 967
 968     package->script->ExecuteSequenceRun = TRUE;
 969
 970     /* get the sequence number */
 971     if (UIran)
 972     {
 973         MSIRECORD *row = MSI_QueryGetRecord(package->db, IVQuery);
 974         if( !row )
 975             return ERROR_FUNCTION_FAILED;
 976         seq = MSI_RecordGetInteger(row,1);
 977         msiobj_release(&row->hdr);
 978     }
 979
 980     rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, seq);
 981     if (rc == ERROR_SUCCESS)
 982     {
 983         TRACE("Running the actions\n");
 984
 985         msi_set_property(package->db, cszSourceDir, NULL);
 986
 987         rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, package);
 988         msiobj_release(&view->hdr);
 989     }
 990
 991     return rc;
 992 }
 993
 994 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package)
 995 {
 996     MSIQUERY * view;
 997     UINT rc;
 998     static const WCHAR ExecSeqQuery [] =
 999         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1000          '`','I','n','s','t','a','l','l',
1001          'U','I','S','e','q','u','e','n','c','e','`',
1002          ' ','W','H','E','R','E',' ',
1003          '`','S','e','q','u','e','n','c','e','`',' ',
1004          '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
1005          '`','S','e','q','u','e','n','c','e','`',0};
1006
1007     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
1008     if (rc == ERROR_SUCCESS)
1009     {
1010         TRACE("Running the actions\n");
1011
1012         rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, package);
1013         msiobj_release(&view->hdr);
1014     }
1015
1016     return rc;
1017 }
1018
1019 /********************************************************
1020  * ACTION helper functions and functions that perform the actions
1021  *******************************************************/
1022 static BOOL ACTION_HandleCustomAction( MSIPACKAGE* package, LPCWSTR action,
1023                                        UINT* rc, UINT script, BOOL force )
1024 {
1025     BOOL ret=FALSE;
1026     UINT arc;
1027
1028     arc = ACTION_CustomAction(package, action, script, force);
1029
1030     if (arc != ERROR_CALL_NOT_IMPLEMENTED)
1031     {
1032         *rc = arc;
1033         ret = TRUE;
1034     }
1035     return ret;
1036 }
1037
1038 /*
1039  * Actual Action Handlers
1040  */
1041
1042 static UINT ITERATE_CreateFolders(MSIRECORD *row, LPVOID param)
1043 {
1044     MSIPACKAGE *package = param;
1045     LPCWSTR dir, component;
1046     LPWSTR full_path;
1047     MSIRECORD *uirow;
1048     MSIFOLDER *folder;
1049     MSICOMPONENT *comp;
1050
1051     component = MSI_RecordGetString(row, 2);
1052     if (!component)
1053         return ERROR_SUCCESS;
1054
1055     comp = get_loaded_component(package, component);
1056     if (!comp)
1057         return ERROR_SUCCESS;
1058
1059     if (!comp->Enabled)
1060     {
1061         TRACE("component is disabled\n");
1062         return ERROR_SUCCESS;
1063     }
1064
1065     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
1066     {
1067         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
1068         comp->Action = comp->Installed;
1069         return ERROR_SUCCESS;
1070     }
1071     comp->Action = INSTALLSTATE_LOCAL;
1072
1073     dir = MSI_RecordGetString(row,1);
1074     if (!dir)
1075     {
1076         ERR("Unable to get folder id\n");
1077         return ERROR_SUCCESS;
1078     }
1079
1080     uirow = MSI_CreateRecord(1);
1081     MSI_RecordSetStringW(uirow, 1, dir);
1082     ui_actiondata(package, szCreateFolders, uirow);
1083     msiobj_release(&uirow->hdr);
1084
1085     full_path = resolve_folder(package,dir,FALSE,FALSE,TRUE,&folder);
1086     if (!full_path)
1087     {
1088         ERR("Unable to resolve folder id %s\n",debugstr_w(dir));
1089         return ERROR_SUCCESS;
1090     }
1091
1092     TRACE("Folder is %s\n",debugstr_w(full_path));
1093
1094     if (folder->State == 0)
1095         create_full_pathW(full_path);
1096
1097     folder->State = 3;
1098
1099     msi_free(full_path);
1100     return ERROR_SUCCESS;
1101 }
1102
1103 static UINT ACTION_CreateFolders(MSIPACKAGE *package)
1104 {
1105     static const WCHAR ExecSeqQuery[] =
1106         {'S','E','L','E','C','T',' ',
1107          '`','D','i','r','e','c','t','o','r','y','_','`',
1108          ' ','F','R','O','M',' ',
1109          '`','C','r','e','a','t','e','F','o','l','d','e','r','`',0 };
1110     UINT rc;
1111     MSIQUERY *view;
1112
1113     /* create all the empty folders specified in the CreateFolder table */
1114     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view );
1115     if (rc != ERROR_SUCCESS)
1116         return ERROR_SUCCESS;
1117
1118     rc = MSI_IterateRecords(view, NULL, ITERATE_CreateFolders, package);
1119     msiobj_release(&view->hdr);
1120
1121     return rc;
1122 }
1123
1124 static UINT ITERATE_RemoveFolders( MSIRECORD *row, LPVOID param )
1125 {
1126     MSIPACKAGE *package = param;
1127     LPCWSTR dir, component;
1128     LPWSTR full_path;
1129     MSIRECORD *uirow;
1130     MSIFOLDER *folder;
1131     MSICOMPONENT *comp;
1132
1133     component = MSI_RecordGetString(row, 2);
1134     if (!component)
1135         return ERROR_SUCCESS;
1136
1137     comp = get_loaded_component(package, component);
1138     if (!comp)
1139         return ERROR_SUCCESS;
1140
1141     if (!comp->Enabled)
1142     {
1143         TRACE("component is disabled\n");
1144         return ERROR_SUCCESS;
1145     }
1146
1147     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
1148     {
1149         TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
1150         comp->Action = comp->Installed;
1151         return ERROR_SUCCESS;
1152     }
1153     comp->Action = INSTALLSTATE_ABSENT;
1154
1155     dir = MSI_RecordGetString( row, 1 );
1156     if (!dir)
1157     {
1158         ERR("Unable to get folder id\n");
1159         return ERROR_SUCCESS;
1160     }
1161
1162     full_path = resolve_folder( package, dir, FALSE, FALSE, TRUE, &folder );
1163     if (!full_path)
1164     {
1165         ERR("Unable to resolve folder id %s\n", debugstr_w(dir));
1166         return ERROR_SUCCESS;
1167     }
1168
1169     TRACE("folder is %s\n", debugstr_w(full_path));
1170
1171     uirow = MSI_CreateRecord( 1 );
1172     MSI_RecordSetStringW( uirow, 1, dir );
1173     ui_actiondata( package, szRemoveFolders, uirow );
1174     msiobj_release( &uirow->hdr );
1175
1176     RemoveDirectoryW( full_path );
1177     folder->State = 0;
1178
1179     msi_free( full_path );
1180     return ERROR_SUCCESS;
1181 }
1182
1183 static UINT ACTION_RemoveFolders( MSIPACKAGE *package )
1184 {
1185     static const WCHAR query[] =
1186         {'S','E','L','E','C','T',' ', '`','D','i','r','e','c','t','o','r','y','_','`',
1187          ' ','F','R','O','M',' ', '`','C','r','e','a','t','e','F','o','l','d','e','r','`',0};
1188
1189     MSIQUERY *view;
1190     UINT rc;
1191
1192     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
1193     if (rc != ERROR_SUCCESS)
1194         return ERROR_SUCCESS;
1195
1196     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveFolders, package );
1197     msiobj_release( &view->hdr );
1198
1199     return rc;
1200 }
1201
1202 static UINT load_component( MSIRECORD *row, LPVOID param )
1203 {
1204     MSIPACKAGE *package = param;
1205     MSICOMPONENT *comp;
1206
1207     comp = msi_alloc_zero( sizeof(MSICOMPONENT) );
1208     if (!comp)
1209         return ERROR_FUNCTION_FAILED;
1210
1211     list_add_tail( &package->components, &comp->entry );
1212
1213     /* fill in the data */
1214     comp->Component = msi_dup_record_field( row, 1 );
1215
1216     TRACE("Loading Component %s\n", debugstr_w(comp->Component));
1217
1218     comp->ComponentId = msi_dup_record_field( row, 2 );
1219     comp->Directory = msi_dup_record_field( row, 3 );
1220     comp->Attributes = MSI_RecordGetInteger(row,4);
1221     comp->Condition = msi_dup_record_field( row, 5 );
1222     comp->KeyPath = msi_dup_record_field( row, 6 );
1223
1224     comp->Installed = INSTALLSTATE_UNKNOWN;
1225     msi_component_set_state(package, comp, INSTALLSTATE_UNKNOWN);
1226
1227     comp->assembly = load_assembly( package, comp );
1228     return ERROR_SUCCESS;
1229 }
1230
1231 static UINT load_all_components( MSIPACKAGE *package )
1232 {
1233     static const WCHAR query[] = {
1234         'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1235          '`','C','o','m','p','o','n','e','n','t','`',0 };
1236     MSIQUERY *view;
1237     UINT r;
1238
1239     if (!list_empty(&package->components))
1240         return ERROR_SUCCESS;
1241
1242     r = MSI_DatabaseOpenViewW( package->db, query, &view );
1243     if (r != ERROR_SUCCESS)
1244         return r;
1245
1246     r = MSI_IterateRecords(view, NULL, load_component, package);
1247     msiobj_release(&view->hdr);
1248     return r;
1249 }
1250
1251 typedef struct {
1252     MSIPACKAGE *package;
1253     MSIFEATURE *feature;
1254 } _ilfs;
1255
1256 static UINT add_feature_component( MSIFEATURE *feature, MSICOMPONENT *comp )
1257 {
1258     ComponentList *cl;
1259
1260     cl = msi_alloc( sizeof (*cl) );
1261     if ( !cl )
1262         return ERROR_NOT_ENOUGH_MEMORY;
1263     cl->component = comp;
1264     list_add_tail( &feature->Components, &cl->entry );
1265
1266     return ERROR_SUCCESS;
1267 }
1268
1269 static UINT add_feature_child( MSIFEATURE *parent, MSIFEATURE *child )
1270 {
1271     FeatureList *fl;
1272
1273     fl = msi_alloc( sizeof(*fl) );
1274     if ( !fl )
1275         return ERROR_NOT_ENOUGH_MEMORY;
1276     fl->feature = child;
1277     list_add_tail( &parent->Children, &fl->entry );
1278
1279     return ERROR_SUCCESS;
1280 }
1281
1282 static UINT iterate_load_featurecomponents(MSIRECORD *row, LPVOID param)
1283 {
1284     _ilfs* ilfs = param;
1285     LPCWSTR component;
1286     MSICOMPONENT *comp;
1287
1288     component = MSI_RecordGetString(row,1);
1289
1290     /* check to see if the component is already loaded */
1291     comp = get_loaded_component( ilfs->package, component );
1292     if (!comp)
1293     {
1294         ERR("unknown component %s\n", debugstr_w(component));
1295         return ERROR_FUNCTION_FAILED;
1296     }
1297
1298     add_feature_component( ilfs->feature, comp );
1299     comp->Enabled = TRUE;
1300
1301     return ERROR_SUCCESS;
1302 }
1303
1304 static MSIFEATURE *find_feature_by_name( MSIPACKAGE *package, LPCWSTR name )
1305 {
1306     MSIFEATURE *feature;
1307
1308     if ( !name )
1309         return NULL;
1310
1311     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1312     {
1313         if ( !strcmpW( feature->Feature, name ) )
1314             return feature;
1315     }
1316
1317     return NULL;
1318 }
1319
1320 static UINT load_feature(MSIRECORD * row, LPVOID param)
1321 {
1322     MSIPACKAGE* package = param;
1323     MSIFEATURE* feature;
1324     static const WCHAR Query1[] =
1325         {'S','E','L','E','C','T',' ',
1326          '`','C','o','m','p','o','n','e','n','t','_','`',
1327          ' ','F','R','O','M',' ','`','F','e','a','t','u','r','e',
1328          'C','o','m','p','o','n','e','n','t','s','`',' ',
1329          'W','H','E','R','E',' ',
1330          '`','F','e', 'a','t','u','r','e','_','`',' ','=','\'','%','s','\'',0};
1331     MSIQUERY * view;
1332     UINT    rc;
1333     _ilfs ilfs;
1334
1335     /* fill in the data */
1336
1337     feature = msi_alloc_zero( sizeof (MSIFEATURE) );
1338     if (!feature)
1339         return ERROR_NOT_ENOUGH_MEMORY;
1340
1341     list_init( &feature->Children );
1342     list_init( &feature->Components );
1343
1344     feature->Feature = msi_dup_record_field( row, 1 );
1345
1346     TRACE("Loading feature %s\n",debugstr_w(feature->Feature));
1347
1348     feature->Feature_Parent = msi_dup_record_field( row, 2 );
1349     feature->Title = msi_dup_record_field( row, 3 );
1350     feature->Description = msi_dup_record_field( row, 4 );
1351
1352     if (!MSI_RecordIsNull(row,5))
1353         feature->Display = MSI_RecordGetInteger(row,5);
1354
1355     feature->Level= MSI_RecordGetInteger(row,6);
1356     feature->Directory = msi_dup_record_field( row, 7 );
1357     feature->Attributes = MSI_RecordGetInteger(row,8);
1358
1359     feature->Installed = INSTALLSTATE_UNKNOWN;
1360     msi_feature_set_state(package, feature, INSTALLSTATE_UNKNOWN);
1361
1362     list_add_tail( &package->features, &feature->entry );
1363
1364     /* load feature components */
1365
1366     rc = MSI_OpenQuery( package->db, &view, Query1, feature->Feature );
1367     if (rc != ERROR_SUCCESS)
1368         return ERROR_SUCCESS;
1369
1370     ilfs.package = package;
1371     ilfs.feature = feature;
1372
1373     MSI_IterateRecords(view, NULL, iterate_load_featurecomponents , &ilfs);
1374     msiobj_release(&view->hdr);
1375
1376     return ERROR_SUCCESS;
1377 }
1378
1379 static UINT find_feature_children(MSIRECORD * row, LPVOID param)
1380 {
1381     MSIPACKAGE* package = param;
1382     MSIFEATURE *parent, *child;
1383
1384     child = find_feature_by_name( package, MSI_RecordGetString( row, 1 ) );
1385     if (!child)
1386         return ERROR_FUNCTION_FAILED;
1387
1388     if (!child->Feature_Parent)
1389         return ERROR_SUCCESS;
1390
1391     parent = find_feature_by_name( package, child->Feature_Parent );
1392     if (!parent)
1393         return ERROR_FUNCTION_FAILED;
1394
1395     add_feature_child( parent, child );
1396     return ERROR_SUCCESS;
1397 }
1398
1399 static UINT load_all_features( MSIPACKAGE *package )
1400 {
1401     static const WCHAR query[] = {
1402         'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1403         '`','F','e','a','t','u','r','e','`',' ','O','R','D','E','R',
1404         ' ','B','Y',' ','`','D','i','s','p','l','a','y','`',0};
1405     MSIQUERY *view;
1406     UINT r;
1407
1408     if (!list_empty(&package->features))
1409         return ERROR_SUCCESS;
1410
1411     r = MSI_DatabaseOpenViewW( package->db, query, &view );
1412     if (r != ERROR_SUCCESS)
1413         return r;
1414
1415     r = MSI_IterateRecords( view, NULL, load_feature, package );
1416     if (r != ERROR_SUCCESS)
1417         return r;
1418
1419     r = MSI_IterateRecords( view, NULL, find_feature_children, package );
1420     msiobj_release( &view->hdr );
1421
1422     return r;
1423 }
1424
1425 static LPWSTR folder_split_path(LPWSTR p, WCHAR ch)
1426 {
1427     if (!p)
1428         return p;
1429     p = strchrW(p, ch);
1430     if (!p)
1431         return p;
1432     *p = 0;
1433     return p+1;
1434 }
1435
1436 static UINT load_file_hash(MSIPACKAGE *package, MSIFILE *file)
1437 {
1438     static const WCHAR query[] = {
1439         'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1440         '`','M','s','i','F','i','l','e','H','a','s','h','`',' ',
1441         'W','H','E','R','E',' ','`','F','i','l','e','_','`',' ','=',' ','\'','%','s','\'',0};
1442     MSIQUERY *view = NULL;
1443     MSIRECORD *row = NULL;
1444     UINT r;
1445
1446     TRACE("%s\n", debugstr_w(file->File));
1447
1448     r = MSI_OpenQuery(package->db, &view, query, file->File);
1449     if (r != ERROR_SUCCESS)
1450         goto done;
1451
1452     r = MSI_ViewExecute(view, NULL);
1453     if (r != ERROR_SUCCESS)
1454         goto done;
1455
1456     r = MSI_ViewFetch(view, &row);
1457     if (r != ERROR_SUCCESS)
1458         goto done;
1459
1460     file->hash.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
1461     file->hash.dwData[0] = MSI_RecordGetInteger(row, 3);
1462     file->hash.dwData[1] = MSI_RecordGetInteger(row, 4);
1463     file->hash.dwData[2] = MSI_RecordGetInteger(row, 5);
1464     file->hash.dwData[3] = MSI_RecordGetInteger(row, 6);
1465
1466 done:
1467     if (view) msiobj_release(&view->hdr);
1468     if (row) msiobj_release(&row->hdr);
1469     return r;
1470 }
1471
1472 static UINT load_file_disk_id( MSIPACKAGE *package, MSIFILE *file )
1473 {
1474     MSIRECORD *row;
1475     static const WCHAR query[] = {
1476         'S','E','L','E','C','T',' ','`','D','i','s','k','I','d','`',' ', 'F','R','O','M',' ',
1477         '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
1478         '`','L','a','s','t','S','e','q','u','e','n','c','e','`',' ','>','=',' ','%','i',0};
1479
1480     row = MSI_QueryGetRecord( package->db, query, file->Sequence );
1481     if (!row)
1482     {
1483         WARN("query failed\n");
1484         return ERROR_FUNCTION_FAILED;
1485     }
1486
1487     file->disk_id = MSI_RecordGetInteger( row, 1 );
1488     msiobj_release( &row->hdr );
1489     return ERROR_SUCCESS;
1490 }
1491
1492 static UINT load_file(MSIRECORD *row, LPVOID param)
1493 {
1494     MSIPACKAGE* package = param;
1495     LPCWSTR component;
1496     MSIFILE *file;
1497
1498     /* fill in the data */
1499
1500     file = msi_alloc_zero( sizeof (MSIFILE) );
1501     if (!file)
1502         return ERROR_NOT_ENOUGH_MEMORY;
1503
1504     file->File = msi_dup_record_field( row, 1 );
1505
1506     component = MSI_RecordGetString( row, 2 );
1507     file->Component = get_loaded_component( package, component );
1508
1509     if (!file->Component)
1510     {
1511         WARN("Component not found: %s\n", debugstr_w(component));
1512         msi_free(file->File);
1513         msi_free(file);
1514         return ERROR_SUCCESS;
1515     }
1516
1517     file->FileName = msi_dup_record_field( row, 3 );
1518     reduce_to_longfilename( file->FileName );
1519
1520     file->ShortName = msi_dup_record_field( row, 3 );
1521     file->LongName = strdupW( folder_split_path(file->ShortName, '|'));
1522
1523     file->FileSize = MSI_RecordGetInteger( row, 4 );
1524     file->Version = msi_dup_record_field( row, 5 );
1525     file->Language = msi_dup_record_field( row, 6 );
1526     file->Attributes = MSI_RecordGetInteger( row, 7 );
1527     file->Sequence = MSI_RecordGetInteger( row, 8 );
1528
1529     file->state = msifs_invalid;
1530
1531     /* if the compressed bits are not set in the file attributes,
1532      * then read the information from the package word count property
1533      */
1534     if (package->WordCount & msidbSumInfoSourceTypeAdminImage)
1535     {
1536         file->IsCompressed = FALSE;
1537     }
1538     else if (file->Attributes &
1539              (msidbFileAttributesCompressed | msidbFileAttributesPatchAdded))
1540     {
1541         file->IsCompressed = TRUE;
1542     }
1543     else if (file->Attributes & msidbFileAttributesNoncompressed)
1544     {
1545         file->IsCompressed = FALSE;
1546     }
1547     else
1548     {
1549         file->IsCompressed = package->WordCount & msidbSumInfoSourceTypeCompressed;
1550     }
1551
1552     load_file_hash(package, file);
1553     load_file_disk_id(package, file);
1554
1555     TRACE("File Loaded (%s)\n",debugstr_w(file->File));
1556
1557     list_add_tail( &package->files, &file->entry );
1558
1559     return ERROR_SUCCESS;
1560 }
1561
1562 static UINT load_all_files(MSIPACKAGE *package)
1563 {
1564     MSIQUERY * view;
1565     UINT rc;
1566     static const WCHAR Query[] =
1567         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1568          '`','F','i','l','e','`',' ', 'O','R','D','E','R',' ','B','Y',' ',
1569          '`','S','e','q','u','e','n','c','e','`', 0};
1570
1571     if (!list_empty(&package->files))
1572         return ERROR_SUCCESS;
1573
1574     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
1575     if (rc != ERROR_SUCCESS)
1576         return ERROR_SUCCESS;
1577
1578     rc = MSI_IterateRecords(view, NULL, load_file, package);
1579     msiobj_release(&view->hdr);
1580
1581     return ERROR_SUCCESS;
1582 }
1583
1584 static UINT load_folder( MSIRECORD *row, LPVOID param )
1585 {
1586     MSIPACKAGE *package = param;
1587     static WCHAR szEmpty[] = { 0 };
1588     LPWSTR p, tgt_short, tgt_long, src_short, src_long;
1589     MSIFOLDER *folder;
1590
1591     folder = msi_alloc_zero( sizeof (MSIFOLDER) );
1592     if (!folder)
1593         return ERROR_NOT_ENOUGH_MEMORY;
1594
1595     folder->Directory = msi_dup_record_field( row, 1 );
1596
1597     TRACE("%s\n", debugstr_w(folder->Directory));
1598
1599     p = msi_dup_record_field(row, 3);
1600
1601     /* split src and target dir */
1602     tgt_short = p;
1603     src_short = folder_split_path( p, ':' );
1604
1605     /* split the long and short paths */
1606     tgt_long = folder_split_path( tgt_short, '|' );
1607     src_long = folder_split_path( src_short, '|' );
1608
1609     /* check for no-op dirs */
1610     if (tgt_short && !strcmpW( szDot, tgt_short ))
1611         tgt_short = szEmpty;
1612     if (src_short && !strcmpW( szDot, src_short ))
1613         src_short = szEmpty;
1614
1615     if (!tgt_long)
1616         tgt_long = tgt_short;
1617
1618     if (!src_short) {
1619         src_short = tgt_short;
1620         src_long = tgt_long;
1621     }
1622
1623     if (!src_long)
1624         src_long = src_short;
1625
1626     /* FIXME: use the target short path too */
1627     folder->TargetDefault = strdupW(tgt_long);
1628     folder->SourceShortPath = strdupW(src_short);
1629     folder->SourceLongPath = strdupW(src_long);
1630     msi_free(p);
1631
1632     TRACE("TargetDefault = %s\n",debugstr_w( folder->TargetDefault ));
1633     TRACE("SourceLong = %s\n", debugstr_w( folder->SourceLongPath ));
1634     TRACE("SourceShort = %s\n", debugstr_w( folder->SourceShortPath ));
1635
1636     folder->Parent = msi_dup_record_field( row, 2 );
1637
1638     folder->Property = msi_dup_property( package->db, folder->Directory );
1639
1640     list_add_tail( &package->folders, &folder->entry );
1641
1642     TRACE("returning %p\n", folder);
1643
1644     return ERROR_SUCCESS;
1645 }
1646
1647 static UINT load_all_folders( MSIPACKAGE *package )
1648 {
1649     static const WCHAR query[] = {
1650         'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1651          '`','D','i','r','e','c','t','o','r','y','`',0 };
1652     MSIQUERY *view;
1653     UINT r;
1654
1655     if (!list_empty(&package->folders))
1656         return ERROR_SUCCESS;
1657
1658     r = MSI_DatabaseOpenViewW( package->db, query, &view );
1659     if (r != ERROR_SUCCESS)
1660         return r;
1661
1662     r = MSI_IterateRecords(view, NULL, load_folder, package);
1663     msiobj_release(&view->hdr);
1664     return r;
1665 }
1666
1667 /*
1668  * I am not doing any of the costing functionality yet.
1669  * Mostly looking at doing the Component and Feature loading
1670  *
1671  * The native MSI does A LOT of modification to tables here. Mostly adding
1672  * a lot of temporary columns to the Feature and Component tables.
1673  *
1674  *    note: Native msi also tracks the short filename. But I am only going to
1675  *          track the long ones.  Also looking at this directory table
1676  *          it appears that the directory table does not get the parents
1677  *          resolved base on property only based on their entries in the
1678  *          directory table.
1679  */
1680 static UINT ACTION_CostInitialize(MSIPACKAGE *package)
1681 {
1682     static const WCHAR szCosting[] =
1683         {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
1684
1685     msi_set_property( package->db, szCosting, szZero );
1686     msi_set_property( package->db, cszRootDrive, c_colon );
1687
1688     load_all_folders( package );
1689     load_all_components( package );
1690     load_all_features( package );
1691     load_all_files( package );
1692
1693     return ERROR_SUCCESS;
1694 }
1695
1696 static UINT execute_script(MSIPACKAGE *package, UINT script )
1697 {
1698     UINT i;
1699     UINT rc = ERROR_SUCCESS;
1700
1701     TRACE("Executing Script %i\n",script);
1702
1703     if (!package->script)
1704     {
1705         ERR("no script!\n");
1706         return ERROR_FUNCTION_FAILED;
1707     }
1708
1709     for (i = 0; i < package->script->ActionCount[script]; i++)
1710     {
1711         LPWSTR action;
1712         action = package->script->Actions[script][i];
1713         ui_actionstart(package, action);
1714         TRACE("Executing Action (%s)\n",debugstr_w(action));
1715         rc = ACTION_PerformAction(package, action, script);
1716         if (rc != ERROR_SUCCESS)
1717             break;
1718     }
1719     msi_free_action_script(package, script);
1720     return rc;
1721 }
1722
1723 static UINT ACTION_FileCost(MSIPACKAGE *package)
1724 {
1725     return ERROR_SUCCESS;
1726 }
1727
1728 static void ACTION_GetComponentInstallStates(MSIPACKAGE *package)
1729 {
1730     MSICOMPONENT *comp;
1731     INSTALLSTATE state;
1732     UINT r;
1733
1734     state = MsiQueryProductStateW(package->ProductCode);
1735
1736     LIST_FOR_EACH_ENTRY(comp, &package->components, MSICOMPONENT, entry)
1737     {
1738         if (!comp->ComponentId)
1739             continue;
1740
1741         if (state != INSTALLSTATE_LOCAL && state != INSTALLSTATE_DEFAULT)
1742             comp->Installed = INSTALLSTATE_ABSENT;
1743         else
1744         {
1745             r = MsiQueryComponentStateW(package->ProductCode, NULL,
1746                                         package->Context, comp->ComponentId,
1747                                         &comp->Installed);
1748             if (r != ERROR_SUCCESS)
1749                 comp->Installed = INSTALLSTATE_ABSENT;
1750         }
1751     }
1752 }
1753
1754 static void ACTION_GetFeatureInstallStates(MSIPACKAGE *package)
1755 {
1756     MSIFEATURE *feature;
1757     INSTALLSTATE state;
1758
1759     state = MsiQueryProductStateW(package->ProductCode);
1760
1761     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1762     {
1763         if (state != INSTALLSTATE_LOCAL && state != INSTALLSTATE_DEFAULT)
1764             feature->Installed = INSTALLSTATE_ABSENT;
1765         else
1766         {
1767             feature->Installed = MsiQueryFeatureStateW(package->ProductCode,
1768                                                        feature->Feature);
1769         }
1770     }
1771 }
1772
1773 static BOOL process_state_property(MSIPACKAGE* package, int level,
1774                                    LPCWSTR property, INSTALLSTATE state)
1775 {
1776     LPWSTR override;
1777     MSIFEATURE *feature;
1778
1779     override = msi_dup_property( package->db, property );
1780     if (!override)
1781         return FALSE;
1782
1783     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1784     {
1785         if (strcmpW( property, szRemove ) &&
1786             (feature->Level <= 0 || feature->Level > level))
1787             continue;
1788
1789         if (!strcmpW(property, szReinstall)) state = feature->Installed;
1790
1791         if (!strcmpiW( override, szAll ))
1792             msi_feature_set_state(package, feature, state);
1793         else
1794         {
1795             LPWSTR ptr = override;
1796             LPWSTR ptr2 = strchrW(override,',');
1797
1798             while (ptr)
1799             {
1800                 int len = ptr2 - ptr;
1801
1802                 if ((ptr2 && strlenW(feature->Feature) == len && !strncmpW(ptr, feature->Feature, len))
1803                     || (!ptr2 && !strcmpW(ptr, feature->Feature)))
1804                 {
1805                     msi_feature_set_state(package, feature, state);
1806                     break;
1807                 }
1808                 if (ptr2)
1809                 {
1810                     ptr=ptr2+1;
1811                     ptr2 = strchrW(ptr,',');
1812                 }
1813                 else
1814                     break;
1815             }
1816         }
1817     }
1818     msi_free(override);
1819
1820     return TRUE;
1821 }
1822
1823 static BOOL process_overrides( MSIPACKAGE *package, int level )
1824 {
1825     static const WCHAR szAddLocal[] =
1826         {'A','D','D','L','O','C','A','L',0};
1827     static const WCHAR szAddSource[] =
1828         {'A','D','D','S','O','U','R','C','E',0};
1829     static const WCHAR szAdvertise[] =
1830         {'A','D','V','E','R','T','I','S','E',0};
1831     BOOL ret = FALSE;
1832
1833     /* all these activation/deactivation things happen in order and things
1834      * later on the list override things earlier on the list.
1835      *
1836      *  0  INSTALLLEVEL processing
1837      *  1  ADDLOCAL
1838      *  2  REMOVE
1839      *  3  ADDSOURCE
1840      *  4  ADDDEFAULT
1841      *  5  REINSTALL
1842      *  6  ADVERTISE
1843      *  7  COMPADDLOCAL
1844      *  8  COMPADDSOURCE
1845      *  9  FILEADDLOCAL
1846      * 10  FILEADDSOURCE
1847      * 11  FILEADDDEFAULT
1848      */
1849     ret |= process_state_property( package, level, szAddLocal, INSTALLSTATE_LOCAL );
1850     ret |= process_state_property( package, level, szRemove, INSTALLSTATE_ABSENT );
1851     ret |= process_state_property( package, level, szAddSource, INSTALLSTATE_SOURCE );
1852     ret |= process_state_property( package, level, szReinstall, INSTALLSTATE_UNKNOWN );
1853     ret |= process_state_property( package, level, szAdvertise, INSTALLSTATE_ADVERTISED );
1854
1855     if (ret)
1856         msi_set_property( package->db, szPreselected, szOne );
1857
1858     return ret;
1859 }
1860
1861 UINT MSI_SetFeatureStates(MSIPACKAGE *package)
1862 {
1863     int level;
1864     static const WCHAR szlevel[] =
1865         {'I','N','S','T','A','L','L','L','E','V','E','L',0};
1866     MSICOMPONENT* component;
1867     MSIFEATURE *feature;
1868
1869     TRACE("Checking Install Level\n");
1870
1871     level = msi_get_property_int(package->db, szlevel, 1);
1872
1873     if (!msi_get_property_int( package->db, szPreselected, 0 ))
1874     {
1875         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1876         {
1877             BOOL feature_state = ((feature->Level > 0) &&
1878                                   (feature->Level <= level));
1879
1880             if (feature_state && feature->ActionRequest == INSTALLSTATE_UNKNOWN)
1881             {
1882                 if (feature->Attributes & msidbFeatureAttributesFavorSource)
1883                     msi_feature_set_state(package, feature, INSTALLSTATE_SOURCE);
1884                 else if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1885                     msi_feature_set_state(package, feature, INSTALLSTATE_ADVERTISED);
1886                 else
1887                     msi_feature_set_state(package, feature, INSTALLSTATE_LOCAL);
1888             }
1889         }
1890
1891         /* disable child features of unselected parent features */
1892         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1893         {
1894             FeatureList *fl;
1895
1896             if (feature->Level > 0 && feature->Level <= level)
1897                 continue;
1898
1899             LIST_FOR_EACH_ENTRY( fl, &feature->Children, FeatureList, entry )
1900                 msi_feature_set_state(package, fl->feature, INSTALLSTATE_UNKNOWN);
1901         }
1902     }
1903     else
1904     {
1905         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1906         {
1907             BOOL selected = feature->Level > 0 && feature->Level <= level;
1908
1909             if (selected && feature->ActionRequest == INSTALLSTATE_UNKNOWN)
1910             {
1911                  msi_feature_set_state(package, feature, feature->Installed);
1912             }
1913         }
1914     }
1915
1916     /*
1917      * now we want to enable or disable components based on feature
1918      */
1919     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1920     {
1921         ComponentList *cl;
1922
1923         TRACE("Examining Feature %s (Level %d Installed %d Request %d Action %d)\n",
1924               debugstr_w(feature->Feature), feature->Level, feature->Installed,
1925               feature->ActionRequest, feature->Action);
1926
1927         if (!feature->Level)
1928             continue;
1929
1930         /* features with components that have compressed files are made local */
1931         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1932         {
1933             if (cl->component->ForceLocalState &&
1934                 feature->ActionRequest == INSTALLSTATE_SOURCE)
1935             {
1936                 msi_feature_set_state(package, feature, INSTALLSTATE_LOCAL);
1937                 break;
1938             }
1939         }
1940
1941         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1942         {
1943             component = cl->component;
1944
1945             switch (feature->ActionRequest)
1946             {
1947             case INSTALLSTATE_ABSENT:
1948                 component->anyAbsent = 1;
1949                 break;
1950             case INSTALLSTATE_ADVERTISED:
1951                 component->hasAdvertiseFeature = 1;
1952                 break;
1953             case INSTALLSTATE_SOURCE:
1954                 component->hasSourceFeature = 1;
1955                 break;
1956             case INSTALLSTATE_LOCAL:
1957                 component->hasLocalFeature = 1;
1958                 break;
1959             case INSTALLSTATE_DEFAULT:
1960                 if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1961                     component->hasAdvertiseFeature = 1;
1962                 else if (feature->Attributes & msidbFeatureAttributesFavorSource)
1963                     component->hasSourceFeature = 1;
1964                 else
1965                     component->hasLocalFeature = 1;
1966                 break;
1967             default:
1968                 break;
1969             }
1970         }
1971     }
1972
1973     LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1974     {
1975         /* check if it's local or source */
1976         if (!(component->Attributes & msidbComponentAttributesOptional) &&
1977              (component->hasLocalFeature || component->hasSourceFeature))
1978         {
1979             if ((component->Attributes & msidbComponentAttributesSourceOnly) &&
1980                  !component->ForceLocalState)
1981                 msi_component_set_state(package, component, INSTALLSTATE_SOURCE);
1982             else
1983                 msi_component_set_state(package, component, INSTALLSTATE_LOCAL);
1984             continue;
1985         }
1986
1987         /* if any feature is local, the component must be local too */
1988         if (component->hasLocalFeature)
1989         {
1990             msi_component_set_state(package, component, INSTALLSTATE_LOCAL);
1991             continue;
1992         }
1993
1994         if (component->hasSourceFeature)
1995         {
1996             msi_component_set_state(package, component, INSTALLSTATE_SOURCE);
1997             continue;
1998         }
1999
2000         if (component->hasAdvertiseFeature)
2001         {
2002             msi_component_set_state(package, component, INSTALLSTATE_ADVERTISED);
2003             continue;
2004         }
2005
2006         TRACE("nobody wants component %s\n", debugstr_w(component->Component));
2007         if (component->anyAbsent)
2008             msi_component_set_state(package, component, INSTALLSTATE_ABSENT);
2009     }
2010
2011     LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
2012     {
2013         if (component->ActionRequest == INSTALLSTATE_DEFAULT)
2014         {
2015             TRACE("%s was default, setting to local\n", debugstr_w(component->Component));
2016             msi_component_set_state(package, component, INSTALLSTATE_LOCAL);
2017         }
2018
2019         TRACE("Result: Component %s (Installed %d Request %d Action %d)\n",
2020               debugstr_w(component->Component), component->Installed, component->ActionRequest, component->Action);
2021     }
2022
2023     return ERROR_SUCCESS;
2024 }
2025
2026 static UINT ITERATE_CostFinalizeDirectories(MSIRECORD *row, LPVOID param)
2027 {
2028     MSIPACKAGE *package = param;
2029     LPCWSTR name;
2030     LPWSTR path;
2031     MSIFOLDER *f;
2032
2033     name = MSI_RecordGetString(row,1);
2034
2035     f = get_loaded_folder(package, name);
2036     if (!f) return ERROR_SUCCESS;
2037
2038     /* reset the ResolvedTarget */
2039     msi_free(f->ResolvedTarget);
2040     f->ResolvedTarget = NULL;
2041
2042     /* This helper function now does ALL the work */
2043     TRACE("Dir %s ...\n",debugstr_w(name));
2044     path = resolve_folder(package,name,FALSE,TRUE,TRUE,NULL);
2045     TRACE("resolves to %s\n",debugstr_w(path));
2046     msi_free(path);
2047
2048     return ERROR_SUCCESS;
2049 }
2050
2051 static UINT ITERATE_CostFinalizeConditions(MSIRECORD *row, LPVOID param)
2052 {
2053     MSIPACKAGE *package = param;
2054     LPCWSTR name;
2055     MSIFEATURE *feature;
2056
2057     name = MSI_RecordGetString( row, 1 );
2058
2059     feature = get_loaded_feature( package, name );
2060     if (!feature)
2061         ERR("FAILED to find loaded feature %s\n",debugstr_w(name));
2062     else
2063     {
2064         LPCWSTR Condition;
2065         Condition = MSI_RecordGetString(row,3);
2066
2067         if (MSI_EvaluateConditionW(package,Condition) == MSICONDITION_TRUE)
2068         {
2069             int level = MSI_RecordGetInteger(row,2);
2070             TRACE("Resetting feature %s to level %i\n", debugstr_w(name), level);
2071             feature->Level = level;
2072         }
2073     }
2074     return ERROR_SUCCESS;
2075 }
2076
2077 VS_FIXEDFILEINFO *msi_get_disk_file_version( LPCWSTR filename )
2078 {
2079     static const WCHAR name[] = {'\\',0};
2080     VS_FIXEDFILEINFO *ptr, *ret;
2081     LPVOID version;
2082     DWORD versize, handle;
2083     UINT sz;
2084
2085     TRACE("%s\n", debugstr_w(filename));
2086
2087     versize = GetFileVersionInfoSizeW( filename, &handle );
2088     if (!versize)
2089         return NULL;
2090
2091     version = msi_alloc( versize );
2092     if (!version)
2093         return NULL;
2094
2095     GetFileVersionInfoW( filename, 0, versize, version );
2096
2097     if (!VerQueryValueW( version, name, (LPVOID *)&ptr, &sz ))
2098     {
2099         msi_free( version );
2100         return NULL;
2101     }
2102
2103     ret = msi_alloc( sz );
2104     memcpy( ret, ptr, sz );
2105
2106     msi_free( version );
2107     return ret;
2108 }
2109
2110 int msi_compare_file_versions( VS_FIXEDFILEINFO *fi, const WCHAR *version )
2111 {
2112     DWORD ms, ls;
2113
2114     msi_parse_version_string( version, &ms, &ls );
2115
2116     if (fi->dwFileVersionMS > ms) return 1;
2117     else if (fi->dwFileVersionMS < ms) return -1;
2118     else if (fi->dwFileVersionLS > ls) return 1;
2119     else if (fi->dwFileVersionLS < ls) return -1;
2120     return 0;
2121 }
2122
2123 static DWORD get_disk_file_size( LPCWSTR filename )
2124 {
2125     HANDLE file;
2126     DWORD size;
2127
2128     TRACE("%s\n", debugstr_w(filename));
2129
2130     file = CreateFileW( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
2131     if (file == INVALID_HANDLE_VALUE)
2132         return INVALID_FILE_SIZE;
2133
2134     size = GetFileSize( file, NULL );
2135     CloseHandle( file );
2136     return size;
2137 }
2138
2139 static BOOL hash_matches( MSIFILE *file )
2140 {
2141     UINT r;
2142     MSIFILEHASHINFO hash;
2143
2144     hash.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
2145     r = MsiGetFileHashW( file->TargetPath, 0, &hash );
2146     if (r != ERROR_SUCCESS)
2147         return FALSE;
2148
2149     return !memcmp( &hash, &file->hash, sizeof(MSIFILEHASHINFO) );
2150 }
2151
2152 static WCHAR *get_temp_dir( void )
2153 {
2154     static UINT id;
2155     WCHAR tmp[MAX_PATH], dir[MAX_PATH];
2156
2157     GetTempPathW( MAX_PATH, tmp );
2158     for (;;)
2159     {
2160         if (!GetTempFileNameW( tmp, szMsi, ++id, dir )) return NULL;
2161         if (CreateDirectoryW( dir, NULL )) break;
2162     }
2163     return strdupW( dir );
2164 }
2165
2166 static void set_target_path( MSIPACKAGE *package, MSIFILE *file )
2167 {
2168     MSIASSEMBLY *assembly = file->Component->assembly;
2169
2170     TRACE("file %s is named %s\n", debugstr_w(file->File), debugstr_w(file->FileName));
2171
2172     msi_free( file->TargetPath );
2173     if (assembly && !assembly->application)
2174     {
2175         if (!assembly->tempdir) assembly->tempdir = get_temp_dir();
2176         file->TargetPath = build_directory_name( 2, assembly->tempdir, file->FileName );
2177         track_tempfile( package, file->TargetPath );
2178     }
2179     else
2180     {
2181         WCHAR *dir = resolve_folder( package, file->Component->Directory, FALSE, FALSE, TRUE, NULL );
2182         file->TargetPath = build_directory_name( 2, dir, file->FileName );
2183         msi_free( dir );
2184     }
2185
2186     TRACE("resolves to %s\n", debugstr_w(file->TargetPath));
2187 }
2188
2189 static UINT set_file_install_states( MSIPACKAGE *package )
2190 {
2191     VS_FIXEDFILEINFO *file_version;
2192     MSIFILE *file;
2193
2194     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2195     {
2196         MSICOMPONENT *comp = file->Component;
2197         DWORD file_size;
2198
2199         if (!comp->Enabled) continue;
2200
2201         if (file->IsCompressed)
2202             comp->ForceLocalState = TRUE;
2203
2204         set_target_path( package, file );
2205
2206         if ((comp->assembly && !comp->assembly->installed) ||
2207             GetFileAttributesW(file->TargetPath) == INVALID_FILE_ATTRIBUTES)
2208         {
2209             file->state = msifs_missing;
2210             comp->Cost += file->FileSize;
2211             continue;
2212         }
2213         if (file->Version && (file_version = msi_get_disk_file_version( file->TargetPath )))
2214         {
2215             TRACE("new %s old %u.%u.%u.%u\n", debugstr_w(file->Version),
2216                   HIWORD(file_version->dwFileVersionMS),
2217                   LOWORD(file_version->dwFileVersionMS),
2218                   HIWORD(file_version->dwFileVersionLS),
2219                   LOWORD(file_version->dwFileVersionLS));
2220
2221             if (msi_compare_file_versions( file_version, file->Version ) < 0)
2222             {
2223                 file->state = msifs_overwrite;
2224                 comp->Cost += file->FileSize;
2225             }
2226             else
2227             {
2228                 TRACE("Destination file version equal or greater, not overwriting\n");
2229                 file->state = msifs_present;
2230             }
2231             msi_free( file_version );
2232             continue;
2233         }
2234         if ((file_size = get_disk_file_size( file->TargetPath )) != file->FileSize)
2235         {
2236             file->state = msifs_overwrite;
2237             comp->Cost += file->FileSize - file_size;
2238             continue;
2239         }
2240         if (file->hash.dwFileHashInfoSize && hash_matches( file ))
2241         {
2242             TRACE("File hashes match, not overwriting\n");
2243             file->state = msifs_present;
2244             continue;
2245         }
2246         file->state = msifs_overwrite;
2247         comp->Cost += file->FileSize - file_size;
2248     }
2249
2250     return ERROR_SUCCESS;
2251 }
2252
2253 /*
2254  * A lot is done in this function aside from just the costing.
2255  * The costing needs to be implemented at some point but for now I am going
2256  * to focus on the directory building
2257  *
2258  */
2259 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
2260 {
2261     static const WCHAR ExecSeqQuery[] =
2262         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2263          '`','D','i','r','e','c','t','o','r','y','`',0};
2264     static const WCHAR ConditionQuery[] =
2265         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2266          '`','C','o','n','d','i','t','i','o','n','`',0};
2267     static const WCHAR szCosting[] =
2268         {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
2269     static const WCHAR szlevel[] =
2270         {'I','N','S','T','A','L','L','L','E','V','E','L',0};
2271     static const WCHAR szOutOfDiskSpace[] =
2272         {'O','u','t','O','f','D','i','s','k','S','p','a','c','e',0};
2273     MSICOMPONENT *comp;
2274     UINT rc = ERROR_SUCCESS;
2275     MSIQUERY * view;
2276     LPWSTR level;
2277
2278     TRACE("Building Directory properties\n");
2279
2280     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2281     if (rc == ERROR_SUCCESS)
2282     {
2283         rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeDirectories,
2284                         package);
2285         msiobj_release(&view->hdr);
2286     }
2287
2288     /* read components states from the registry */
2289     ACTION_GetComponentInstallStates(package);
2290     ACTION_GetFeatureInstallStates(package);
2291
2292     if (!process_overrides( package, msi_get_property_int( package->db, szlevel, 1 ) ))
2293     {
2294         TRACE("Evaluating feature conditions\n");
2295
2296         rc = MSI_DatabaseOpenViewW( package->db, ConditionQuery, &view );
2297         if (rc == ERROR_SUCCESS)
2298         {
2299             rc = MSI_IterateRecords( view, NULL, ITERATE_CostFinalizeConditions, package );
2300             msiobj_release( &view->hdr );
2301         }
2302     }
2303     TRACE("Evaluating component conditions\n");
2304
2305     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2306     {
2307         if (MSI_EvaluateConditionW( package, comp->Condition ) == MSICONDITION_FALSE)
2308         {
2309             TRACE("Disabling component %s\n", debugstr_w(comp->Component));
2310             comp->Enabled = FALSE;
2311         }
2312         else
2313             comp->Enabled = TRUE;
2314     }
2315
2316     TRACE("Calculating file install states\n");
2317     set_file_install_states( package );
2318
2319     msi_set_property( package->db, szCosting, szOne );
2320     /* set default run level if not set */
2321     level = msi_dup_property( package->db, szlevel );
2322     if (!level)
2323         msi_set_property( package->db, szlevel, szOne );
2324     msi_free(level);
2325
2326     /* FIXME: check volume disk space */
2327     msi_set_property( package->db, szOutOfDiskSpace, szZero );
2328
2329     return MSI_SetFeatureStates(package);
2330 }
2331
2332 /* OK this value is "interpreted" and then formatted based on the
2333    first few characters */
2334 static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
2335                          DWORD *size)
2336 {
2337     LPSTR data = NULL;
2338
2339     if (value[0]=='#' && value[1]!='#' && value[1]!='%')
2340     {
2341         if (value[1]=='x')
2342         {
2343             LPWSTR ptr;
2344             CHAR byte[5];
2345             LPWSTR deformated = NULL;
2346             int count;
2347
2348             deformat_string(package, &value[2], &deformated);
2349
2350             /* binary value type */
2351             ptr = deformated;
2352             *type = REG_BINARY;
2353             if (strlenW(ptr)%2)
2354                 *size = (strlenW(ptr)/2)+1;
2355             else
2356                 *size = strlenW(ptr)/2;
2357
2358             data = msi_alloc(*size);
2359
2360             byte[0] = '0';
2361             byte[1] = 'x';
2362             byte[4] = 0;
2363             count = 0;
2364             /* if uneven pad with a zero in front */
2365             if (strlenW(ptr)%2)
2366             {
2367                 byte[2]= '0';
2368                 byte[3]= *ptr;
2369                 ptr++;
2370                 data[count] = (BYTE)strtol(byte,NULL,0);
2371                 count ++;
2372                 TRACE("Uneven byte count\n");
2373             }
2374             while (*ptr)
2375             {
2376                 byte[2]= *ptr;
2377                 ptr++;
2378                 byte[3]= *ptr;
2379                 ptr++;
2380                 data[count] = (BYTE)strtol(byte,NULL,0);
2381                 count ++;
2382             }
2383             msi_free(deformated);
2384
2385             TRACE("Data %i bytes(%i)\n",*size,count);
2386         }
2387         else
2388         {
2389             LPWSTR deformated;
2390             LPWSTR p;
2391             DWORD d = 0;
2392             deformat_string(package, &value[1], &deformated);
2393
2394             *type=REG_DWORD;
2395             *size = sizeof(DWORD);
2396             data = msi_alloc(*size);
2397             p = deformated;
2398             if (*p == '-')
2399                 p++;
2400             while (*p)
2401             {
2402                 if ( (*p < '0') || (*p > '9') )
2403                     break;
2404                 d *= 10;
2405                 d += (*p - '0');
2406                 p++;
2407             }
2408             if (deformated[0] == '-')
2409                 d = -d;
2410             *(LPDWORD)data = d;
2411             TRACE("DWORD %i\n",*(LPDWORD)data);
2412
2413             msi_free(deformated);
2414         }
2415     }
2416     else
2417     {
2418         static const WCHAR szMulti[] = {'[','~',']',0};
2419         LPCWSTR ptr;
2420         *type=REG_SZ;
2421
2422         if (value[0]=='#')
2423         {
2424             if (value[1]=='%')
2425             {
2426                 ptr = &value[2];
2427                 *type=REG_EXPAND_SZ;
2428             }
2429             else
2430                 ptr = &value[1];
2431          }
2432          else
2433             ptr=value;
2434
2435         if (strstrW(value, szMulti))
2436             *type = REG_MULTI_SZ;
2437
2438         /* remove initial delimiter */
2439         if (!strncmpW(value, szMulti, 3))
2440             ptr = value + 3;
2441
2442         *size = deformat_string(package, ptr,(LPWSTR*)&data);
2443
2444         /* add double NULL terminator */
2445         if (*type == REG_MULTI_SZ)
2446         {
2447             *size += 2 * sizeof(WCHAR); /* two NULL terminators */
2448             data = msi_realloc_zero(data, *size);
2449         }
2450     }
2451     return data;
2452 }
2453
2454 static const WCHAR *get_root_key( MSIPACKAGE *package, INT root, HKEY *root_key )
2455 {
2456     const WCHAR *ret;
2457
2458     switch (root)
2459     {
2460     case -1:
2461         if (msi_get_property_int( package->db, szAllUsers, 0 ))
2462         {
2463             *root_key = HKEY_LOCAL_MACHINE;
2464             ret = szHLM;
2465         }
2466         else
2467         {
2468             *root_key = HKEY_CURRENT_USER;
2469             ret = szHCU;
2470         }
2471         break;
2472     case 0:
2473         *root_key = HKEY_CLASSES_ROOT;
2474         ret = szHCR;
2475         break;
2476     case 1:
2477         *root_key = HKEY_CURRENT_USER;
2478         ret = szHCU;
2479         break;
2480     case 2:
2481         *root_key = HKEY_LOCAL_MACHINE;
2482         ret = szHLM;
2483         break;
2484     case 3:
2485         *root_key = HKEY_USERS;
2486         ret = szHU;
2487         break;
2488     default:
2489         ERR("Unknown root %i\n", root);
2490         return NULL;
2491     }
2492
2493     return ret;
2494 }
2495
2496 static WCHAR *get_keypath( MSIPACKAGE *package, HKEY root, const WCHAR *path )
2497 {
2498     static const WCHAR prefixW[] = {'S','O','F','T','W','A','R','E','\\'};
2499     static const UINT len = sizeof(prefixW) / sizeof(prefixW[0]);
2500
2501     if (is_64bit && package->platform == PLATFORM_INTEL &&
2502         root == HKEY_LOCAL_MACHINE && !strncmpiW( path, prefixW, len ))
2503     {
2504         UINT size;
2505         WCHAR *path_32node;
2506
2507         size = (strlenW( path ) + strlenW( szWow6432Node ) + 1) * sizeof(WCHAR);
2508         path_32node = msi_alloc( size );
2509         if (!path_32node)
2510             return NULL;
2511
2512         memcpy( path_32node, path, len * sizeof(WCHAR) );
2513         path_32node[len] = 0;
2514         strcatW( path_32node, szWow6432Node );
2515         strcatW( path_32node, szBackSlash );
2516         strcatW( path_32node, path + len );
2517         return path_32node;
2518     }
2519
2520     return strdupW( path );
2521 }
2522
2523 static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
2524 {
2525     MSIPACKAGE *package = param;
2526     LPSTR value_data = NULL;
2527     HKEY  root_key, hkey;
2528     DWORD type,size;
2529     LPWSTR deformated, uikey, keypath;
2530     LPCWSTR szRoot, component, name, key, value;
2531     MSICOMPONENT *comp;
2532     MSIRECORD * uirow;
2533     INT   root;
2534     BOOL check_first = FALSE;
2535     UINT rc;
2536
2537     ui_progress(package,2,0,0,0);
2538
2539     component = MSI_RecordGetString(row, 6);
2540     comp = get_loaded_component(package,component);
2541     if (!comp)
2542         return ERROR_SUCCESS;
2543
2544     if (!comp->Enabled)
2545     {
2546         TRACE("component is disabled\n");
2547         return ERROR_SUCCESS;
2548     }
2549
2550     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
2551     {
2552         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
2553         comp->Action = comp->Installed;
2554         return ERROR_SUCCESS;
2555     }
2556     comp->Action = INSTALLSTATE_LOCAL;
2557
2558     name = MSI_RecordGetString(row, 4);
2559     if( MSI_RecordIsNull(row,5) && name )
2560     {
2561         /* null values can have special meanings */
2562         if (name[0]=='-' && name[1] == 0)
2563                 return ERROR_SUCCESS;
2564         else if ((name[0]=='+' && name[1] == 0) ||
2565                  (name[0] == '*' && name[1] == 0))
2566                 name = NULL;
2567         check_first = TRUE;
2568     }
2569
2570     root = MSI_RecordGetInteger(row,2);
2571     key = MSI_RecordGetString(row, 3);
2572
2573     szRoot = get_root_key( package, root, &root_key );
2574     if (!szRoot)
2575         return ERROR_SUCCESS;
2576
2577     deformat_string(package, key , &deformated);
2578     size = strlenW(deformated) + strlenW(szRoot) + 1;
2579     uikey = msi_alloc(size*sizeof(WCHAR));
2580     strcpyW(uikey,szRoot);
2581     strcatW(uikey,deformated);
2582
2583     keypath = get_keypath( package, root_key, deformated );
2584     msi_free( deformated );
2585     if (RegCreateKeyW( root_key, keypath, &hkey ))
2586     {
2587         ERR("Could not create key %s\n", debugstr_w(keypath));
2588         msi_free(uikey);
2589         return ERROR_SUCCESS;
2590     }
2591
2592     value = MSI_RecordGetString(row,5);
2593     if (value)
2594         value_data = parse_value(package, value, &type, &size);
2595     else
2596     {
2597         value_data = (LPSTR)strdupW(szEmpty);
2598         size = sizeof(szEmpty);
2599         type = REG_SZ;
2600     }
2601
2602     deformat_string(package, name, &deformated);
2603
2604     if (!check_first)
2605     {
2606         TRACE("Setting value %s of %s\n",debugstr_w(deformated),
2607                         debugstr_w(uikey));
2608         RegSetValueExW(hkey, deformated, 0, type, (LPBYTE)value_data, size);
2609     }
2610     else
2611     {
2612         DWORD sz = 0;
2613         rc = RegQueryValueExW(hkey, deformated, NULL, NULL, NULL, &sz);
2614         if (rc == ERROR_SUCCESS || rc == ERROR_MORE_DATA)
2615         {
2616             TRACE("value %s of %s checked already exists\n",
2617                             debugstr_w(deformated), debugstr_w(uikey));
2618         }
2619         else
2620         {
2621             TRACE("Checked and setting value %s of %s\n",
2622                             debugstr_w(deformated), debugstr_w(uikey));
2623             if (deformated || size)
2624                 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE) value_data, size);
2625         }
2626     }
2627     RegCloseKey(hkey);
2628
2629     uirow = MSI_CreateRecord(3);
2630     MSI_RecordSetStringW(uirow,2,deformated);
2631     MSI_RecordSetStringW(uirow,1,uikey);
2632     if (type == REG_SZ || type == REG_EXPAND_SZ)
2633         MSI_RecordSetStringW(uirow,3,(LPWSTR)value_data);
2634     ui_actiondata(package,szWriteRegistryValues,uirow);
2635     msiobj_release( &uirow->hdr );
2636
2637     msi_free(value_data);
2638     msi_free(deformated);
2639     msi_free(uikey);
2640
2641     return ERROR_SUCCESS;
2642 }
2643
2644 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
2645 {
2646     UINT rc;
2647     MSIQUERY * view;
2648     static const WCHAR ExecSeqQuery[] =
2649         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2650          '`','R','e','g','i','s','t','r','y','`',0 };
2651
2652     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2653     if (rc != ERROR_SUCCESS)
2654         return ERROR_SUCCESS;
2655
2656     /* increment progress bar each time action data is sent */
2657     ui_progress(package,1,REG_PROGRESS_VALUE,1,0);
2658
2659     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteRegistryValues, package);
2660
2661     msiobj_release(&view->hdr);
2662     return rc;
2663 }
2664
2665 static void delete_reg_key_or_value( HKEY hkey_root, LPCWSTR key, LPCWSTR value, BOOL delete_key )
2666 {
2667     LONG res;
2668     HKEY hkey;
2669     DWORD num_subkeys, num_values;
2670
2671     if (delete_key)
2672     {
2673         if ((res = RegDeleteTreeW( hkey_root, key )))
2674         {
2675             TRACE("Failed to delete key %s (%d)\n", debugstr_w(key), res);
2676         }
2677         return;
2678     }
2679
2680     if (!(res = RegOpenKeyW( hkey_root, key, &hkey )))
2681     {
2682         if ((res = RegDeleteValueW( hkey, value )))
2683         {
2684             TRACE("Failed to delete value %s (%d)\n", debugstr_w(value), res);
2685         }
2686         res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, &num_subkeys, NULL, NULL, &num_values,
2687                                 NULL, NULL, NULL, NULL );
2688         RegCloseKey( hkey );
2689         if (!res && !num_subkeys && !num_values)
2690         {
2691             TRACE("Removing empty key %s\n", debugstr_w(key));
2692             RegDeleteKeyW( hkey_root, key );
2693         }
2694         return;
2695     }
2696     TRACE("Failed to open key %s (%d)\n", debugstr_w(key), res);
2697 }
2698
2699
2700 static UINT ITERATE_RemoveRegistryValuesOnUninstall( MSIRECORD *row, LPVOID param )
2701 {
2702     MSIPACKAGE *package = param;
2703     LPCWSTR component, name, key_str, root_key_str;
2704     LPWSTR deformated_key, deformated_name, ui_key_str, keypath;
2705     MSICOMPONENT *comp;
2706     MSIRECORD *uirow;
2707     BOOL delete_key = FALSE;
2708     HKEY hkey_root;
2709     UINT size;
2710     INT root;
2711
2712     ui_progress( package, 2, 0, 0, 0 );
2713
2714     component = MSI_RecordGetString( row, 6 );
2715     comp = get_loaded_component( package, component );
2716     if (!comp)
2717         return ERROR_SUCCESS;
2718
2719     if (!comp->Enabled)
2720     {
2721         TRACE("component is disabled\n");
2722         return ERROR_SUCCESS;
2723     }
2724
2725     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
2726     {
2727         TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
2728         comp->Action = comp->Installed;
2729         return ERROR_SUCCESS;
2730     }
2731     comp->Action = INSTALLSTATE_ABSENT;
2732
2733     name = MSI_RecordGetString( row, 4 );
2734     if (MSI_RecordIsNull( row, 5 ) && name )
2735     {
2736         if (name[0] == '+' && !name[1])
2737             return ERROR_SUCCESS;
2738         else if ((name[0] == '-' && !name[1]) || (name[0] == '*' && !name[1]))
2739         {
2740             delete_key = TRUE;
2741             name = NULL;
2742         }
2743     }
2744
2745     root = MSI_RecordGetInteger( row, 2 );
2746     key_str = MSI_RecordGetString( row, 3 );
2747
2748     root_key_str = get_root_key( package, root, &hkey_root );
2749     if (!root_key_str)
2750         return ERROR_SUCCESS;
2751
2752     deformat_string( package, key_str, &deformated_key );
2753     size = strlenW( deformated_key ) + strlenW( root_key_str ) + 1;
2754     ui_key_str = msi_alloc( size * sizeof(WCHAR) );
2755     strcpyW( ui_key_str, root_key_str );
2756     strcatW( ui_key_str, deformated_key );
2757
2758     deformat_string( package, name, &deformated_name );
2759
2760     keypath = get_keypath( package, hkey_root, deformated_key );
2761     msi_free( deformated_key );
2762     delete_reg_key_or_value( hkey_root, keypath, deformated_name, delete_key );
2763     msi_free( keypath );
2764
2765     uirow = MSI_CreateRecord( 2 );
2766     MSI_RecordSetStringW( uirow, 1, ui_key_str );
2767     MSI_RecordSetStringW( uirow, 2, deformated_name );
2768
2769     ui_actiondata( package, szRemoveRegistryValues, uirow );
2770     msiobj_release( &uirow->hdr );
2771
2772     msi_free( ui_key_str );
2773     msi_free( deformated_name );
2774     return ERROR_SUCCESS;
2775 }
2776
2777 static UINT ITERATE_RemoveRegistryValuesOnInstall( MSIRECORD *row, LPVOID param )
2778 {
2779     MSIPACKAGE *package = param;
2780     LPCWSTR component, name, key_str, root_key_str;
2781     LPWSTR deformated_key, deformated_name, ui_key_str, keypath;
2782     MSICOMPONENT *comp;
2783     MSIRECORD *uirow;
2784     BOOL delete_key = FALSE;
2785     HKEY hkey_root;
2786     UINT size;
2787     INT root;
2788
2789     ui_progress( package, 2, 0, 0, 0 );
2790
2791     component = MSI_RecordGetString( row, 5 );
2792     comp = get_loaded_component( package, component );
2793     if (!comp)
2794         return ERROR_SUCCESS;
2795
2796     if (!comp->Enabled)
2797     {
2798         TRACE("component is disabled\n");
2799         return ERROR_SUCCESS;
2800     }
2801
2802     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
2803     {
2804         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
2805         comp->Action = comp->Installed;
2806         return ERROR_SUCCESS;
2807     }
2808     comp->Action = INSTALLSTATE_LOCAL;
2809
2810     if ((name = MSI_RecordGetString( row, 4 )))
2811     {
2812         if (name[0] == '-' && !name[1])
2813         {
2814             delete_key = TRUE;
2815             name = NULL;
2816         }
2817     }
2818
2819     root = MSI_RecordGetInteger( row, 2 );
2820     key_str = MSI_RecordGetString( row, 3 );
2821
2822     root_key_str = get_root_key( package, root, &hkey_root );
2823     if (!root_key_str)
2824         return ERROR_SUCCESS;
2825
2826     deformat_string( package, key_str, &deformated_key );
2827     size = strlenW( deformated_key ) + strlenW( root_key_str ) + 1;
2828     ui_key_str = msi_alloc( size * sizeof(WCHAR) );
2829     strcpyW( ui_key_str, root_key_str );
2830     strcatW( ui_key_str, deformated_key );
2831
2832     deformat_string( package, name, &deformated_name );
2833
2834     keypath = get_keypath( package, hkey_root, deformated_key );
2835     msi_free( deformated_key );
2836     delete_reg_key_or_value( hkey_root, keypath, deformated_name, delete_key );
2837     msi_free( keypath );
2838
2839     uirow = MSI_CreateRecord( 2 );
2840     MSI_RecordSetStringW( uirow, 1, ui_key_str );
2841     MSI_RecordSetStringW( uirow, 2, deformated_name );
2842
2843     ui_actiondata( package, szRemoveRegistryValues, uirow );
2844     msiobj_release( &uirow->hdr );
2845
2846     msi_free( ui_key_str );
2847     msi_free( deformated_name );
2848     return ERROR_SUCCESS;
2849 }
2850
2851 static UINT ACTION_RemoveRegistryValues( MSIPACKAGE *package )
2852 {
2853     UINT rc;
2854     MSIQUERY *view;
2855     static const WCHAR registry_query[] =
2856         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2857          '`','R','e','g','i','s','t','r','y','`',0 };
2858     static const WCHAR remove_registry_query[] =
2859         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2860          '`','R','e','m','o','v','e','R','e','g','i','s','t','r','y','`',0 };
2861
2862     /* increment progress bar each time action data is sent */
2863     ui_progress( package, 1, REG_PROGRESS_VALUE, 1, 0 );
2864
2865     rc = MSI_DatabaseOpenViewW( package->db, registry_query, &view );
2866     if (rc == ERROR_SUCCESS)
2867     {
2868         rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveRegistryValuesOnUninstall, package );
2869         msiobj_release( &view->hdr );
2870         if (rc != ERROR_SUCCESS)
2871             return rc;
2872     }
2873
2874     rc = MSI_DatabaseOpenViewW( package->db, remove_registry_query, &view );
2875     if (rc == ERROR_SUCCESS)
2876     {
2877         rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveRegistryValuesOnInstall, package );
2878         msiobj_release( &view->hdr );
2879         if (rc != ERROR_SUCCESS)
2880             return rc;
2881     }
2882
2883     return ERROR_SUCCESS;
2884 }
2885
2886 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
2887 {
2888     package->script->CurrentlyScripting = TRUE;
2889
2890     return ERROR_SUCCESS;
2891 }
2892
2893
2894 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
2895 {
2896     MSICOMPONENT *comp;
2897     DWORD progress = 0;
2898     DWORD total = 0;
2899     static const WCHAR q1[]=
2900         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
2901          '`','R','e','g','i','s','t','r','y','`',0};
2902     UINT rc;
2903     MSIQUERY * view;
2904     MSIFEATURE *feature;
2905     MSIFILE *file;
2906
2907     TRACE("InstallValidate\n");
2908
2909     rc = MSI_DatabaseOpenViewW(package->db, q1, &view);
2910     if (rc == ERROR_SUCCESS)
2911     {
2912         MSI_IterateRecords( view, &progress, NULL, package );
2913         msiobj_release( &view->hdr );
2914         total += progress * REG_PROGRESS_VALUE;
2915     }
2916
2917     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2918         total += COMPONENT_PROGRESS_VALUE;
2919
2920     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2921         total += file->FileSize;
2922
2923     ui_progress(package,0,total,0,0);
2924
2925     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2926     {
2927         TRACE("Feature: %s Installed %d Request %d Action %d\n",
2928               debugstr_w(feature->Feature), feature->Installed,
2929               feature->ActionRequest, feature->Action);
2930     }
2931
2932     return ERROR_SUCCESS;
2933 }
2934
2935 static UINT ITERATE_LaunchConditions(MSIRECORD *row, LPVOID param)
2936 {
2937     MSIPACKAGE* package = param;
2938     LPCWSTR cond = NULL;
2939     LPCWSTR message = NULL;
2940     UINT r;
2941
2942     static const WCHAR title[]=
2943         {'I','n','s','t','a','l','l',' ','F','a', 'i','l','e','d',0};
2944
2945     cond = MSI_RecordGetString(row,1);
2946
2947     r = MSI_EvaluateConditionW(package,cond);
2948     if (r == MSICONDITION_FALSE)
2949     {
2950         if ((gUILevel & INSTALLUILEVEL_MASK) != INSTALLUILEVEL_NONE)
2951         {
2952             LPWSTR deformated;
2953             message = MSI_RecordGetString(row,2);
2954             deformat_string(package,message,&deformated);
2955             MessageBoxW(NULL,deformated,title,MB_OK);
2956             msi_free(deformated);
2957         }
2958
2959         return ERROR_INSTALL_FAILURE;
2960     }
2961
2962     return ERROR_SUCCESS;
2963 }
2964
2965 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
2966 {
2967     UINT rc;
2968     MSIQUERY * view = NULL;
2969     static const WCHAR ExecSeqQuery[] =
2970         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2971          '`','L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','`',0};
2972
2973     TRACE("Checking launch conditions\n");
2974
2975     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2976     if (rc != ERROR_SUCCESS)
2977         return ERROR_SUCCESS;
2978
2979     rc = MSI_IterateRecords(view, NULL, ITERATE_LaunchConditions, package);
2980     msiobj_release(&view->hdr);
2981
2982     return rc;
2983 }
2984
2985 static LPWSTR resolve_keypath( MSIPACKAGE* package, MSICOMPONENT *cmp )
2986 {
2987
2988     if (!cmp->KeyPath)
2989         return resolve_folder(package,cmp->Directory,FALSE,FALSE,TRUE,NULL);
2990
2991     if (cmp->Attributes & msidbComponentAttributesRegistryKeyPath)
2992     {
2993         MSIRECORD * row = 0;
2994         UINT root,len;
2995         LPWSTR deformated,buffer,deformated_name;
2996         LPCWSTR key,name;
2997         static const WCHAR ExecSeqQuery[] =
2998             {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2999              '`','R','e','g','i','s','t','r','y','`',' ',
3000              'W','H','E','R','E',' ', '`','R','e','g','i','s','t','r','y','`',
3001              ' ','=',' ' ,'\'','%','s','\'',0 };
3002         static const WCHAR fmt[]={'%','0','2','i',':','\\','%','s','\\',0};
3003         static const WCHAR fmt2[]=
3004             {'%','0','2','i',':','\\','%','s','\\','%','s',0};
3005
3006         row = MSI_QueryGetRecord(package->db, ExecSeqQuery,cmp->KeyPath);
3007         if (!row)
3008             return NULL;
3009
3010         root = MSI_RecordGetInteger(row,2);
3011         key = MSI_RecordGetString(row, 3);
3012         name = MSI_RecordGetString(row, 4);
3013         deformat_string(package, key , &deformated);
3014         deformat_string(package, name, &deformated_name);
3015
3016         len = strlenW(deformated) + 6;
3017         if (deformated_name)
3018             len+=strlenW(deformated_name);
3019
3020         buffer = msi_alloc( len *sizeof(WCHAR));
3021
3022         if (deformated_name)
3023             sprintfW(buffer,fmt2,root,deformated,deformated_name);
3024         else
3025             sprintfW(buffer,fmt,root,deformated);
3026
3027         msi_free(deformated);
3028         msi_free(deformated_name);
3029         msiobj_release(&row->hdr);
3030
3031         return buffer;
3032     }
3033     else if (cmp->Attributes & msidbComponentAttributesODBCDataSource)
3034     {
3035         FIXME("UNIMPLEMENTED keypath as ODBC Source\n");
3036         return NULL;
3037     }
3038     else
3039     {
3040         MSIFILE *file = get_loaded_file( package, cmp->KeyPath );
3041
3042         if (file)
3043             return strdupW( file->TargetPath );
3044     }
3045     return NULL;
3046 }
3047
3048 static HKEY openSharedDLLsKey(void)
3049 {
3050     HKEY hkey=0;
3051     static const WCHAR path[] =
3052         {'S','o','f','t','w','a','r','e','\\',
3053          'M','i','c','r','o','s','o','f','t','\\',
3054          'W','i','n','d','o','w','s','\\',
3055          'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3056          'S','h','a','r','e','d','D','L','L','s',0};
3057
3058     RegCreateKeyW(HKEY_LOCAL_MACHINE,path,&hkey);
3059     return hkey;
3060 }
3061
3062 static UINT ACTION_GetSharedDLLsCount(LPCWSTR dll)
3063 {
3064     HKEY hkey;
3065     DWORD count=0;
3066     DWORD type;
3067     DWORD sz = sizeof(count);
3068     DWORD rc;
3069
3070     hkey = openSharedDLLsKey();
3071     rc = RegQueryValueExW(hkey, dll, NULL, &type, (LPBYTE)&count, &sz);
3072     if (rc != ERROR_SUCCESS)
3073         count = 0;
3074     RegCloseKey(hkey);
3075     return count;
3076 }
3077
3078 static UINT ACTION_WriteSharedDLLsCount(LPCWSTR path, UINT count)
3079 {
3080     HKEY hkey;
3081
3082     hkey = openSharedDLLsKey();
3083     if (count > 0)
3084         msi_reg_set_val_dword( hkey, path, count );
3085     else
3086         RegDeleteValueW(hkey,path);
3087     RegCloseKey(hkey);
3088     return count;
3089 }
3090
3091 /*
3092  * Return TRUE if the count should be written out and FALSE if not
3093  */
3094 static void ACTION_RefCountComponent( MSIPACKAGE* package, MSICOMPONENT *comp )
3095 {
3096     MSIFEATURE *feature;
3097     INT count = 0;
3098     BOOL write = FALSE;
3099
3100     /* only refcount DLLs */
3101     if (comp->KeyPath == NULL ||
3102         comp->Attributes & msidbComponentAttributesRegistryKeyPath ||
3103         comp->Attributes & msidbComponentAttributesODBCDataSource)
3104         write = FALSE;
3105     else
3106     {
3107         count = ACTION_GetSharedDLLsCount( comp->FullKeypath);
3108         write = (count > 0);
3109
3110         if (comp->Attributes & msidbComponentAttributesSharedDllRefCount)
3111             write = TRUE;
3112     }
3113
3114     /* increment counts */
3115     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3116     {
3117         ComponentList *cl;
3118
3119         if (feature->ActionRequest != INSTALLSTATE_LOCAL)
3120             continue;
3121
3122         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3123         {
3124             if ( cl->component == comp )
3125                 count++;
3126         }
3127     }
3128
3129     /* decrement counts */
3130     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3131     {
3132         ComponentList *cl;
3133
3134         if (feature->ActionRequest != INSTALLSTATE_ABSENT)
3135             continue;
3136
3137         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3138         {
3139             if ( cl->component == comp )
3140                 count--;
3141         }
3142     }
3143
3144     /* ref count all the files in the component */
3145     if (write)
3146     {
3147         MSIFILE *file;
3148
3149         LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
3150         {
3151             if (file->Component == comp)
3152                 ACTION_WriteSharedDLLsCount( file->TargetPath, count );
3153         }
3154     }
3155
3156     /* add a count for permanent */
3157     if (comp->Attributes & msidbComponentAttributesPermanent)
3158         count ++;
3159
3160     comp->RefCount = count;
3161
3162     if (write)
3163         ACTION_WriteSharedDLLsCount( comp->FullKeypath, comp->RefCount );
3164 }
3165
3166 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
3167 {
3168     WCHAR squished_pc[GUID_SIZE];
3169     WCHAR squished_cc[GUID_SIZE];
3170     UINT rc;
3171     MSICOMPONENT *comp;
3172     HKEY hkey;
3173
3174     TRACE("\n");
3175
3176     squash_guid(package->ProductCode,squished_pc);
3177     ui_progress(package,1,COMPONENT_PROGRESS_VALUE,1,0);
3178
3179     msi_set_sourcedir_props(package, FALSE);
3180
3181     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
3182     {
3183         MSIRECORD * uirow;
3184
3185         ui_progress(package,2,0,0,0);
3186         if (!comp->ComponentId)
3187             continue;
3188
3189         squash_guid(comp->ComponentId,squished_cc);
3190
3191         msi_free(comp->FullKeypath);
3192         comp->FullKeypath = resolve_keypath( package, comp );
3193
3194         ACTION_RefCountComponent( package, comp );
3195
3196         TRACE("Component %s (%s), Keypath=%s, RefCount=%i Request=%u\n",
3197                             debugstr_w(comp->Component),
3198                             debugstr_w(squished_cc),
3199                             debugstr_w(comp->FullKeypath),
3200                             comp->RefCount,
3201                             comp->ActionRequest);
3202
3203         if (comp->ActionRequest == INSTALLSTATE_LOCAL ||
3204             comp->ActionRequest == INSTALLSTATE_SOURCE)
3205         {
3206             if (!comp->FullKeypath)
3207                 continue;
3208
3209             if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3210                 rc = MSIREG_OpenUserDataComponentKey(comp->ComponentId, szLocalSid,
3211                                                      &hkey, TRUE);
3212             else
3213                 rc = MSIREG_OpenUserDataComponentKey(comp->ComponentId, NULL,
3214                                                      &hkey, TRUE);
3215
3216             if (rc != ERROR_SUCCESS)
3217                 continue;
3218
3219             if (comp->Attributes & msidbComponentAttributesPermanent)
3220             {
3221                 static const WCHAR szPermKey[] =
3222                     { '0','0','0','0','0','0','0','0','0','0','0','0',
3223                       '0','0','0','0','0','0','0','0','0','0','0','0',
3224                       '0','0','0','0','0','0','0','0',0 };
3225
3226                 msi_reg_set_val_str(hkey, szPermKey, comp->FullKeypath);
3227             }
3228
3229             if (comp->ActionRequest == INSTALLSTATE_LOCAL)
3230                 msi_reg_set_val_str(hkey, squished_pc, comp->FullKeypath);
3231             else
3232             {
3233                 MSIFILE *file;
3234                 MSIRECORD *row;
3235                 LPWSTR ptr, ptr2;
3236                 WCHAR source[MAX_PATH];
3237                 WCHAR base[MAX_PATH];
3238                 LPWSTR sourcepath;
3239
3240                 static const WCHAR fmt[] = {'%','0','2','d','\\',0};
3241                 static const WCHAR query[] = {
3242                     'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
3243                     '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
3244                     '`','L','a','s','t','S','e','q','u','e','n','c','e','`',' ',
3245                     '>','=',' ','%','i',' ','O','R','D','E','R',' ','B','Y',' ',
3246                     '`','D','i','s','k','I','d','`',0};
3247
3248                 file = get_loaded_file(package, comp->KeyPath);
3249                 if (!file)
3250                     continue;
3251
3252                 row = MSI_QueryGetRecord(package->db, query, file->Sequence);
3253                 sprintfW(source, fmt, MSI_RecordGetInteger(row, 1));
3254                 ptr2 = strrchrW(source, '\\') + 1;
3255                 msiobj_release(&row->hdr);
3256
3257                 lstrcpyW(base, package->PackagePath);
3258                 ptr = strrchrW(base, '\\');
3259                 *(ptr + 1) = '\0';
3260
3261                 sourcepath = resolve_file_source(package, file);
3262                 ptr = sourcepath + lstrlenW(base);
3263                 lstrcpyW(ptr2, ptr);
3264                 msi_free(sourcepath);
3265
3266                 msi_reg_set_val_str(hkey, squished_pc, source);
3267             }
3268             RegCloseKey(hkey);
3269         }
3270         else if (comp->ActionRequest == INSTALLSTATE_ABSENT)
3271         {
3272             if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3273                 MSIREG_DeleteUserDataComponentKey(comp->ComponentId, szLocalSid);
3274             else
3275                 MSIREG_DeleteUserDataComponentKey(comp->ComponentId, NULL);
3276         }
3277         comp->Action = comp->ActionRequest;
3278
3279         /* UI stuff */
3280         uirow = MSI_CreateRecord(3);
3281         MSI_RecordSetStringW(uirow,1,package->ProductCode);
3282         MSI_RecordSetStringW(uirow,2,comp->ComponentId);
3283         MSI_RecordSetStringW(uirow,3,comp->FullKeypath);
3284         ui_actiondata(package,szProcessComponents,uirow);
3285         msiobj_release( &uirow->hdr );
3286     }
3287
3288     return ERROR_SUCCESS;
3289 }
3290
3291 typedef struct {
3292     CLSID       clsid;
3293     LPWSTR      source;
3294
3295     LPWSTR      path;
3296     ITypeLib    *ptLib;
3297 } typelib_struct;
3298
3299 static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
3300                                        LPWSTR lpszName, LONG_PTR lParam)
3301 {
3302     TLIBATTR *attr;
3303     typelib_struct *tl_struct = (typelib_struct*) lParam;
3304     static const WCHAR fmt[] = {'%','s','\\','%','i',0};
3305     int sz;
3306     HRESULT res;
3307
3308     if (!IS_INTRESOURCE(lpszName))
3309     {
3310         ERR("Not Int Resource Name %s\n",debugstr_w(lpszName));
3311         return TRUE;
3312     }
3313
3314     sz = strlenW(tl_struct->source)+4;
3315     sz *= sizeof(WCHAR);
3316
3317     if ((INT_PTR)lpszName == 1)
3318         tl_struct->path = strdupW(tl_struct->source);
3319     else
3320     {
3321         tl_struct->path = msi_alloc(sz);
3322         sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName);
3323     }
3324
3325     TRACE("trying %s\n", debugstr_w(tl_struct->path));
3326     res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
3327     if (FAILED(res))
3328     {
3329         msi_free(tl_struct->path);
3330         tl_struct->path = NULL;
3331
3332         return TRUE;
3333     }
3334
3335     ITypeLib_GetLibAttr(tl_struct->ptLib, &attr);
3336     if (IsEqualGUID(&(tl_struct->clsid),&(attr->guid)))
3337     {
3338         ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
3339         return FALSE;
3340     }
3341
3342     msi_free(tl_struct->path);
3343     tl_struct->path = NULL;
3344
3345     ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
3346     ITypeLib_Release(tl_struct->ptLib);
3347
3348     return TRUE;
3349 }
3350
3351 static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
3352 {
3353     MSIPACKAGE* package = param;
3354     LPCWSTR component;
3355     MSICOMPONENT *comp;
3356     MSIFILE *file;
3357     typelib_struct tl_struct;
3358     ITypeLib *tlib;
3359     HMODULE module;
3360     HRESULT hr;
3361
3362     component = MSI_RecordGetString(row,3);
3363     comp = get_loaded_component(package,component);
3364     if (!comp)
3365         return ERROR_SUCCESS;
3366
3367     if (!comp->Enabled)
3368     {
3369         TRACE("component is disabled\n");
3370         return ERROR_SUCCESS;
3371     }
3372
3373     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
3374     {
3375         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
3376         comp->Action = comp->Installed;
3377         return ERROR_SUCCESS;
3378     }
3379     comp->Action = INSTALLSTATE_LOCAL;
3380
3381     if (!comp->KeyPath || !(file = get_loaded_file( package, comp->KeyPath )))
3382     {
3383         TRACE("component has no key path\n");
3384         return ERROR_SUCCESS;
3385     }
3386     ui_actiondata( package, szRegisterTypeLibraries, row );
3387
3388     module = LoadLibraryExW( file->TargetPath, NULL, LOAD_LIBRARY_AS_DATAFILE );
3389     if (module)
3390     {
3391         LPCWSTR guid;
3392         guid = MSI_RecordGetString(row,1);
3393         CLSIDFromString((LPCWSTR)guid, &tl_struct.clsid);
3394         tl_struct.source = strdupW( file->TargetPath );
3395         tl_struct.path = NULL;
3396
3397         EnumResourceNamesW(module, szTYPELIB, Typelib_EnumResNameProc,
3398                         (LONG_PTR)&tl_struct);
3399
3400         if (tl_struct.path)
3401         {
3402             LPWSTR help = NULL;
3403             LPCWSTR helpid;
3404             HRESULT res;
3405
3406             helpid = MSI_RecordGetString(row,6);
3407
3408             if (helpid)
3409                 help = resolve_folder(package,helpid,FALSE,FALSE,TRUE,NULL);
3410             res = RegisterTypeLib(tl_struct.ptLib,tl_struct.path,help);
3411             msi_free(help);
3412
3413             if (FAILED(res))
3414                 ERR("Failed to register type library %s\n",
3415                         debugstr_w(tl_struct.path));
3416             else
3417                 TRACE("Registered %s\n", debugstr_w(tl_struct.path));
3418
3419             ITypeLib_Release(tl_struct.ptLib);
3420             msi_free(tl_struct.path);
3421         }
3422         else
3423             ERR("Failed to load type library %s\n",
3424                     debugstr_w(tl_struct.source));
3425
3426         FreeLibrary(module);
3427         msi_free(tl_struct.source);
3428     }
3429     else
3430     {
3431         hr = LoadTypeLibEx(file->TargetPath, REGKIND_REGISTER, &tlib);
3432         if (FAILED(hr))
3433         {
3434             ERR("Failed to load type library: %08x\n", hr);
3435             return ERROR_INSTALL_FAILURE;
3436         }
3437
3438         ITypeLib_Release(tlib);
3439     }
3440
3441     return ERROR_SUCCESS;
3442 }
3443
3444 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
3445 {
3446     /*
3447      * OK this is a bit confusing.. I am given a _Component key and I believe
3448      * that the file that is being registered as a type library is the "key file
3449      * of that component" which I interpret to mean "The file in the KeyPath of
3450      * that component".
3451      */
3452     UINT rc;
3453     MSIQUERY * view;
3454     static const WCHAR Query[] =
3455         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3456          '`','T','y','p','e','L','i','b','`',0};
3457
3458     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3459     if (rc != ERROR_SUCCESS)
3460         return ERROR_SUCCESS;
3461
3462     rc = MSI_IterateRecords(view, NULL, ITERATE_RegisterTypeLibraries, package);
3463     msiobj_release(&view->hdr);
3464     return rc;
3465 }
3466
3467 static UINT ITERATE_UnregisterTypeLibraries( MSIRECORD *row, LPVOID param )
3468 {
3469     MSIPACKAGE *package = param;
3470     LPCWSTR component, guid;
3471     MSICOMPONENT *comp;
3472     GUID libid;
3473     UINT version;
3474     LCID language;
3475     SYSKIND syskind;
3476     HRESULT hr;
3477
3478     component = MSI_RecordGetString( row, 3 );
3479     comp = get_loaded_component( package, component );
3480     if (!comp)
3481         return ERROR_SUCCESS;
3482
3483     if (!comp->Enabled)
3484     {
3485         TRACE("component is disabled\n");
3486         return ERROR_SUCCESS;
3487     }
3488
3489     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
3490     {
3491         TRACE("Component not scheduled for removal %s\n", debugstr_w(component));
3492         comp->Action = comp->Installed;
3493         return ERROR_SUCCESS;
3494     }
3495     comp->Action = INSTALLSTATE_ABSENT;
3496
3497     ui_actiondata( package, szUnregisterTypeLibraries, row );
3498
3499     guid = MSI_RecordGetString( row, 1 );
3500     CLSIDFromString( (LPCWSTR)guid, &libid );
3501     version = MSI_RecordGetInteger( row, 4 );
3502     language = MSI_RecordGetInteger( row, 2 );
3503
3504 #ifdef _WIN64
3505     syskind = SYS_WIN64;
3506 #else
3507     syskind = SYS_WIN32;
3508 #endif
3509
3510     hr = UnRegisterTypeLib( &libid, (version >> 8) & 0xffff, version & 0xff, language, syskind );
3511     if (FAILED(hr))
3512     {
3513         WARN("Failed to unregister typelib: %08x\n", hr);
3514     }
3515
3516     return ERROR_SUCCESS;
3517 }
3518
3519 static UINT ACTION_UnregisterTypeLibraries( MSIPACKAGE *package )
3520 {
3521     UINT rc;
3522     MSIQUERY *view;
3523     static const WCHAR query[] =
3524         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3525          '`','T','y','p','e','L','i','b','`',0};
3526
3527     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
3528     if (rc != ERROR_SUCCESS)
3529         return ERROR_SUCCESS;
3530
3531     rc = MSI_IterateRecords( view, NULL, ITERATE_UnregisterTypeLibraries, package );
3532     msiobj_release( &view->hdr );
3533     return rc;
3534 }
3535
3536 static WCHAR *get_link_file( MSIPACKAGE *package, MSIRECORD *row )
3537 {
3538     static const WCHAR szlnk[] = {'.','l','n','k',0};
3539     LPCWSTR directory, extension;
3540     LPWSTR link_folder, link_file, filename;
3541
3542     directory = MSI_RecordGetString( row, 2 );
3543     link_folder = resolve_folder( package, directory, FALSE, FALSE, TRUE, NULL );
3544
3545     /* may be needed because of a bug somewhere else */
3546     create_full_pathW( link_folder );
3547
3548     filename = msi_dup_record_field( row, 3 );
3549     reduce_to_longfilename( filename );
3550
3551     extension = strchrW( filename, '.' );
3552     if (!extension || strcmpiW( extension, szlnk ))
3553     {
3554         int len = strlenW( filename );
3555         filename = msi_realloc( filename, len * sizeof(WCHAR) + sizeof(szlnk) );
3556         memcpy( filename + len, szlnk, sizeof(szlnk) );
3557     }
3558     link_file = build_directory_name( 2, link_folder, filename );
3559     msi_free( link_folder );
3560     msi_free( filename );
3561
3562     return link_file;
3563 }
3564
3565 static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
3566 {
3567     MSIPACKAGE *package = param;
3568     LPWSTR link_file, deformated, path;
3569     LPCWSTR component, target;
3570     MSICOMPONENT *comp;
3571     IShellLinkW *sl = NULL;
3572     IPersistFile *pf = NULL;
3573     HRESULT res;
3574
3575     component = MSI_RecordGetString(row, 4);
3576     comp = get_loaded_component(package, component);
3577     if (!comp)
3578         return ERROR_SUCCESS;
3579
3580     if (!comp->Enabled)
3581     {
3582         TRACE("component is disabled\n");
3583         return ERROR_SUCCESS;
3584     }
3585
3586     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
3587     {
3588         TRACE("Component not scheduled for installation %s\n", debugstr_w(component));
3589         comp->Action = comp->Installed;
3590         return ERROR_SUCCESS;
3591     }
3592     comp->Action = INSTALLSTATE_LOCAL;
3593
3594     ui_actiondata(package,szCreateShortcuts,row);
3595
3596     res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3597                     &IID_IShellLinkW, (LPVOID *) &sl );
3598
3599     if (FAILED( res ))
3600     {
3601         ERR("CLSID_ShellLink not available\n");
3602         goto err;
3603     }
3604
3605     res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
3606     if (FAILED( res ))
3607     {
3608         ERR("QueryInterface(IID_IPersistFile) failed\n");
3609         goto err;
3610     }
3611
3612     target = MSI_RecordGetString(row, 5);
3613     if (strchrW(target, '['))
3614     {
3615         deformat_string(package, target, &deformated);
3616         IShellLinkW_SetPath(sl,deformated);
3617         msi_free(deformated);
3618     }
3619     else
3620     {
3621         FIXME("poorly handled shortcut format, advertised shortcut\n");
3622         IShellLinkW_SetPath(sl,comp->FullKeypath);
3623     }
3624
3625     if (!MSI_RecordIsNull(row,6))
3626     {
3627         LPCWSTR arguments = MSI_RecordGetString(row, 6);
3628         deformat_string(package, arguments, &deformated);
3629         IShellLinkW_SetArguments(sl,deformated);
3630         msi_free(deformated);
3631     }
3632
3633     if (!MSI_RecordIsNull(row,7))
3634     {
3635         LPCWSTR description = MSI_RecordGetString(row, 7);
3636         IShellLinkW_SetDescription(sl, description);
3637     }
3638
3639     if (!MSI_RecordIsNull(row,8))
3640         IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
3641
3642     if (!MSI_RecordIsNull(row,9))
3643     {
3644         INT index;
3645         LPCWSTR icon = MSI_RecordGetString(row, 9);
3646
3647         path = build_icon_path(package, icon);
3648         index = MSI_RecordGetInteger(row,10);
3649
3650         /* no value means 0 */
3651         if (index == MSI_NULL_INTEGER)
3652             index = 0;
3653
3654         IShellLinkW_SetIconLocation(sl, path, index);
3655         msi_free(path);
3656     }
3657
3658     if (!MSI_RecordIsNull(row,11))
3659         IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
3660
3661     if (!MSI_RecordIsNull(row,12))
3662     {
3663         LPCWSTR wkdir = MSI_RecordGetString(row, 12);
3664         path = resolve_folder(package, wkdir, FALSE, FALSE, TRUE, NULL);
3665         if (path)
3666             IShellLinkW_SetWorkingDirectory(sl, path);
3667         msi_free(path);
3668     }
3669
3670     link_file = get_link_file(package, row);
3671
3672     TRACE("Writing shortcut to %s\n", debugstr_w(link_file));
3673     IPersistFile_Save(pf, link_file, FALSE);
3674
3675     msi_free(link_file);
3676
3677 err:
3678     if (pf)
3679         IPersistFile_Release( pf );
3680     if (sl)
3681         IShellLinkW_Release( sl );
3682
3683     return ERROR_SUCCESS;
3684 }
3685
3686 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
3687 {
3688     UINT rc;
3689     HRESULT res;
3690     MSIQUERY * view;
3691     static const WCHAR Query[] =
3692         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3693          '`','S','h','o','r','t','c','u','t','`',0};
3694
3695     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3696     if (rc != ERROR_SUCCESS)
3697         return ERROR_SUCCESS;
3698
3699     res = CoInitialize( NULL );
3700
3701     rc = MSI_IterateRecords(view, NULL, ITERATE_CreateShortcuts, package);
3702     msiobj_release(&view->hdr);
3703
3704     if (SUCCEEDED(res))
3705         CoUninitialize();
3706
3707     return rc;
3708 }
3709
3710 static UINT ITERATE_RemoveShortcuts( MSIRECORD *row, LPVOID param )
3711 {
3712     MSIPACKAGE *package = param;
3713     LPWSTR link_file;
3714     LPCWSTR component;
3715     MSICOMPONENT *comp;
3716
3717     component = MSI_RecordGetString( row, 4 );
3718     comp = get_loaded_component( package, component );
3719     if (!comp)
3720         return ERROR_SUCCESS;
3721
3722     if (!comp->Enabled)
3723     {
3724         TRACE("component is disabled\n");
3725         return ERROR_SUCCESS;
3726     }
3727
3728     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
3729     {
3730         TRACE("Component not scheduled for removal %s\n", debugstr_w(component));
3731         comp->Action = comp->Installed;
3732         return ERROR_SUCCESS;
3733     }
3734     comp->Action = INSTALLSTATE_ABSENT;
3735
3736     ui_actiondata( package, szRemoveShortcuts, row );
3737
3738     link_file = get_link_file( package, row );
3739
3740     TRACE("Removing shortcut file %s\n", debugstr_w( link_file ));
3741     if (!DeleteFileW( link_file ))
3742     {
3743         WARN("Failed to remove shortcut file %u\n", GetLastError());
3744     }
3745     msi_free( link_file );
3746
3747     return ERROR_SUCCESS;
3748 }
3749
3750 static UINT ACTION_RemoveShortcuts( MSIPACKAGE *package )
3751 {
3752     UINT rc;
3753     MSIQUERY *view;
3754     static const WCHAR query[] =
3755         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3756          '`','S','h','o','r','t','c','u','t','`',0};
3757
3758     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
3759     if (rc != ERROR_SUCCESS)
3760         return ERROR_SUCCESS;
3761
3762     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveShortcuts, package );
3763     msiobj_release( &view->hdr );
3764
3765     return rc;
3766 }
3767
3768 static UINT ITERATE_PublishIcon(MSIRECORD *row, LPVOID param)
3769 {
3770     MSIPACKAGE* package = param;
3771     HANDLE the_file;
3772     LPWSTR FilePath;
3773     LPCWSTR FileName;
3774     CHAR buffer[1024];
3775     DWORD sz;
3776     UINT rc;
3777
3778     FileName = MSI_RecordGetString(row,1);
3779     if (!FileName)
3780     {
3781         ERR("Unable to get FileName\n");
3782         return ERROR_SUCCESS;
3783     }
3784
3785     FilePath = build_icon_path(package,FileName);
3786
3787     TRACE("Creating icon file at %s\n",debugstr_w(FilePath));
3788
3789     the_file = CreateFileW(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
3790                         FILE_ATTRIBUTE_NORMAL, NULL);
3791
3792     if (the_file == INVALID_HANDLE_VALUE)
3793     {
3794         ERR("Unable to create file %s\n",debugstr_w(FilePath));
3795         msi_free(FilePath);
3796         return ERROR_SUCCESS;
3797     }
3798
3799     do
3800     {
3801         DWORD write;
3802         sz = 1024;
3803         rc = MSI_RecordReadStream(row,2,buffer,&sz);
3804         if (rc != ERROR_SUCCESS)
3805         {
3806             ERR("Failed to get stream\n");
3807             CloseHandle(the_file);
3808             DeleteFileW(FilePath);
3809             break;
3810         }
3811         WriteFile(the_file,buffer,sz,&write,NULL);
3812     } while (sz == 1024);
3813
3814     msi_free(FilePath);
3815     CloseHandle(the_file);
3816
3817     return ERROR_SUCCESS;
3818 }
3819
3820 static UINT msi_publish_icons(MSIPACKAGE *package)
3821 {
3822     UINT r;
3823     MSIQUERY *view;
3824
3825     static const WCHAR query[]= {
3826         'S','E','L','E','C','T',' ','*',' ',
3827         'F','R','O','M',' ','`','I','c','o','n','`',0};
3828
3829     r = MSI_DatabaseOpenViewW(package->db, query, &view);
3830     if (r == ERROR_SUCCESS)
3831     {
3832         MSI_IterateRecords(view, NULL, ITERATE_PublishIcon, package);
3833         msiobj_release(&view->hdr);
3834     }
3835
3836     return ERROR_SUCCESS;
3837 }
3838
3839 static UINT msi_publish_sourcelist(MSIPACKAGE *package, HKEY hkey)
3840 {
3841     UINT r;
3842     HKEY source;
3843     LPWSTR buffer;
3844     MSIMEDIADISK *disk;
3845     MSISOURCELISTINFO *info;
3846
3847     r = RegCreateKeyW(hkey, szSourceList, &source);
3848     if (r != ERROR_SUCCESS)
3849         return r;
3850
3851     RegCloseKey(source);
3852
3853     buffer = strrchrW(package->PackagePath, '\\') + 1;
3854     r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3855                               package->Context, MSICODE_PRODUCT,
3856                               INSTALLPROPERTY_PACKAGENAMEW, buffer);
3857     if (r != ERROR_SUCCESS)
3858         return r;
3859
3860     r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3861                               package->Context, MSICODE_PRODUCT,
3862                               INSTALLPROPERTY_MEDIAPACKAGEPATHW, szEmpty);
3863     if (r != ERROR_SUCCESS)
3864         return r;
3865
3866     r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3867                               package->Context, MSICODE_PRODUCT,
3868                               INSTALLPROPERTY_DISKPROMPTW, szEmpty);
3869     if (r != ERROR_SUCCESS)
3870         return r;
3871
3872     LIST_FOR_EACH_ENTRY(info, &package->sourcelist_info, MSISOURCELISTINFO, entry)
3873     {
3874         if (!strcmpW( info->property, INSTALLPROPERTY_LASTUSEDSOURCEW ))
3875             msi_set_last_used_source(package->ProductCode, NULL, info->context,
3876                                      info->options, info->value);
3877         else
3878             MsiSourceListSetInfoW(package->ProductCode, NULL,
3879                                   info->context, info->options,
3880                                   info->property, info->value);
3881     }
3882
3883     LIST_FOR_EACH_ENTRY(disk, &package->sourcelist_media, MSIMEDIADISK, entry)
3884     {
3885         MsiSourceListAddMediaDiskW(package->ProductCode, NULL,
3886                                    disk->context, disk->options,
3887                                    disk->disk_id, disk->volume_label, disk->disk_prompt);
3888     }
3889
3890     return ERROR_SUCCESS;
3891 }
3892
3893 static UINT msi_publish_product_properties(MSIPACKAGE *package, HKEY hkey)
3894 {
3895     MSIHANDLE hdb, suminfo;
3896     WCHAR guids[MAX_PATH];
3897     WCHAR packcode[SQUISH_GUID_SIZE];
3898     LPWSTR buffer;
3899     LPWSTR ptr;
3900     DWORD langid;
3901     DWORD size;
3902     UINT r;
3903
3904     static const WCHAR szProductLanguage[] =
3905         {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3906     static const WCHAR szARPProductIcon[] =
3907         {'A','R','P','P','R','O','D','U','C','T','I','C','O','N',0};
3908     static const WCHAR szProductVersion[] =
3909         {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3910     static const WCHAR szAssignment[] =
3911         {'A','s','s','i','g','n','m','e','n','t',0};
3912     static const WCHAR szAdvertiseFlags[] =
3913         {'A','d','v','e','r','t','i','s','e','F','l','a','g','s',0};
3914     static const WCHAR szClients[] =
3915         {'C','l','i','e','n','t','s',0};
3916     static const WCHAR szColon[] = {':',0};
3917
3918     buffer = msi_dup_property(package->db, INSTALLPROPERTY_PRODUCTNAMEW);
3919     msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTNAMEW, buffer);
3920     msi_free(buffer);
3921
3922     langid = msi_get_property_int(package->db, szProductLanguage, 0);
3923     msi_reg_set_val_dword(hkey, INSTALLPROPERTY_LANGUAGEW, langid);
3924
3925     /* FIXME */
3926     msi_reg_set_val_dword(hkey, INSTALLPROPERTY_AUTHORIZED_LUA_APPW, 0);
3927
3928     buffer = msi_dup_property(package->db, szARPProductIcon);
3929     if (buffer)
3930     {
3931         LPWSTR path = build_icon_path(package,buffer);
3932         msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTICONW, path);
3933         msi_free(path);
3934         msi_free(buffer);
3935     }
3936
3937     buffer = msi_dup_property(package->db, szProductVersion);
3938     if (buffer)
3939     {
3940         DWORD verdword = msi_version_str_to_dword(buffer);
3941         msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONW, verdword);
3942         msi_free(buffer);
3943     }
3944
3945     msi_reg_set_val_dword(hkey, szAssignment, 0);
3946     msi_reg_set_val_dword(hkey, szAdvertiseFlags, 0x184);
3947     msi_reg_set_val_dword(hkey, INSTALLPROPERTY_INSTANCETYPEW, 0);
3948     msi_reg_set_val_str(hkey, szClients, szColon);
3949
3950     hdb = alloc_msihandle(&package->db->hdr);
3951     if (!hdb)
3952         return ERROR_NOT_ENOUGH_MEMORY;
3953
3954     r = MsiGetSummaryInformationW(hdb, NULL, 0, &suminfo);
3955     MsiCloseHandle(hdb);
3956     if (r != ERROR_SUCCESS)
3957         goto done;
3958
3959     size = MAX_PATH;
3960     r = MsiSummaryInfoGetPropertyW(suminfo, PID_REVNUMBER, NULL, NULL,
3961                                    NULL, guids, &size);
3962     if (r != ERROR_SUCCESS)
3963         goto done;
3964
3965     ptr = strchrW(guids, ';');
3966     if (ptr) *ptr = 0;
3967     squash_guid(guids, packcode);
3968     msi_reg_set_val_str(hkey, INSTALLPROPERTY_PACKAGECODEW, packcode);
3969
3970 done:
3971     MsiCloseHandle(suminfo);
3972     return ERROR_SUCCESS;
3973 }
3974
3975 static UINT msi_publish_upgrade_code(MSIPACKAGE *package)
3976 {
3977     UINT r;
3978     HKEY hkey;
3979     LPWSTR upgrade;
3980     WCHAR squashed_pc[SQUISH_GUID_SIZE];
3981
3982     upgrade = msi_dup_property(package->db, szUpgradeCode);
3983     if (!upgrade)
3984         return ERROR_SUCCESS;
3985
3986     if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3987     {
3988         r = MSIREG_OpenClassesUpgradeCodesKey(upgrade, &hkey, TRUE);
3989         if (r != ERROR_SUCCESS)
3990             goto done;
3991     }
3992     else
3993     {
3994         r = MSIREG_OpenUserUpgradeCodesKey(upgrade, &hkey, TRUE);
3995         if (r != ERROR_SUCCESS)
3996             goto done;
3997     }
3998
3999     squash_guid(package->ProductCode, squashed_pc);
4000     msi_reg_set_val_str(hkey, squashed_pc, NULL);
4001
4002     RegCloseKey(hkey);
4003
4004 done:
4005     msi_free(upgrade);
4006     return r;
4007 }
4008
4009 static BOOL msi_check_publish(MSIPACKAGE *package)
4010 {
4011     MSIFEATURE *feature;
4012
4013     LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4014     {
4015         if (feature->ActionRequest == INSTALLSTATE_LOCAL)
4016             return TRUE;
4017     }
4018
4019     return FALSE;
4020 }
4021
4022 static BOOL msi_check_unpublish(MSIPACKAGE *package)
4023 {
4024     MSIFEATURE *feature;
4025
4026     LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4027     {
4028         if (feature->ActionRequest != INSTALLSTATE_ABSENT)
4029             return FALSE;
4030     }
4031
4032     return TRUE;
4033 }
4034
4035 static UINT msi_publish_patches( MSIPACKAGE *package )
4036 {
4037     static const WCHAR szAllPatches[] = {'A','l','l','P','a','t','c','h','e','s',0};
4038     WCHAR patch_squashed[GUID_SIZE];
4039     HKEY patches_key = NULL, product_patches_key = NULL, product_key;
4040     LONG res;
4041     MSIPATCHINFO *patch;
4042     UINT r;
4043     WCHAR *p, *all_patches = NULL;
4044     DWORD len = 0;
4045
4046     r = MSIREG_OpenProductKey( package->ProductCode, NULL, package->Context, &product_key, TRUE );
4047     if (r != ERROR_SUCCESS)
4048         return ERROR_FUNCTION_FAILED;
4049
4050     res = RegCreateKeyExW( product_key, szPatches, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &patches_key, NULL );
4051     if (res != ERROR_SUCCESS)
4052     {
4053         r = ERROR_FUNCTION_FAILED;
4054         goto done;
4055     }
4056
4057     r = MSIREG_OpenUserDataProductPatchesKey( package->ProductCode, package->Context, &product_patches_key, TRUE );
4058     if (r != ERROR_SUCCESS)
4059         goto done;
4060
4061     LIST_FOR_EACH_ENTRY( patch, &package->patches, MSIPATCHINFO, entry )
4062     {
4063         squash_guid( patch->patchcode, patch_squashed );
4064         len += strlenW( patch_squashed ) + 1;
4065     }
4066
4067     p = all_patches = msi_alloc( (len + 1) * sizeof(WCHAR) );
4068     if (!all_patches)
4069         goto done;
4070
4071     LIST_FOR_EACH_ENTRY( patch, &package->patches, MSIPATCHINFO, entry )
4072     {
4073         HKEY patch_key;
4074
4075         squash_guid( patch->patchcode, p );
4076         p += strlenW( p ) + 1;
4077
4078         res = RegSetValueExW( patches_key, patch_squashed, 0, REG_SZ,
4079                               (const BYTE *)patch->transforms,
4080                               (strlenW(patch->transforms) + 1) * sizeof(WCHAR) );
4081         if (res != ERROR_SUCCESS)
4082             goto done;
4083
4084         r = MSIREG_OpenUserDataPatchKey( patch->patchcode, package->Context, &patch_key, TRUE );
4085         if (r != ERROR_SUCCESS)
4086             goto done;
4087
4088         res = RegSetValueExW( patch_key, szLocalPackage, 0, REG_SZ,
4089                               (const BYTE *)patch->localfile,
4090                               (strlenW(patch->localfile) + 1) * sizeof(WCHAR) );
4091         RegCloseKey( patch_key );
4092         if (res != ERROR_SUCCESS)
4093             goto done;
4094
4095         res = RegCreateKeyExW( product_patches_key, patch_squashed, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &patch_key, NULL );
4096         if (res != ERROR_SUCCESS)
4097             goto done;
4098
4099         res = RegSetValueExW( patch_key, szState, 0, REG_DWORD, (const BYTE *)&patch->state, sizeof(patch->state) );
4100         RegCloseKey( patch_key );
4101         if (res != ERROR_SUCCESS)
4102             goto done;
4103     }
4104
4105     all_patches[len] = 0;
4106     res = RegSetValueExW( patches_key, szPatches, 0, REG_MULTI_SZ,
4107                           (const BYTE *)all_patches, (len + 1) * sizeof(WCHAR) );
4108     if (res != ERROR_SUCCESS)
4109         goto done;
4110
4111     res = RegSetValueExW( product_patches_key, szAllPatches, 0, REG_MULTI_SZ,
4112                           (const BYTE *)all_patches, (len + 1) * sizeof(WCHAR) );
4113     if (res != ERROR_SUCCESS)
4114         r = ERROR_FUNCTION_FAILED;
4115
4116 done:
4117     RegCloseKey( product_patches_key );
4118     RegCloseKey( patches_key );
4119     RegCloseKey( product_key );
4120     msi_free( all_patches );
4121     return r;
4122 }
4123
4124 /*
4125  * 99% of the work done here is only done for
4126  * advertised installs. However this is where the
4127  * Icon table is processed and written out
4128  * so that is what I am going to do here.
4129  */
4130 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
4131 {
4132     UINT rc;
4133     HKEY hukey = NULL, hudkey = NULL;
4134     MSIRECORD *uirow;
4135
4136     if (!list_empty(&package->patches))
4137     {
4138         rc = msi_publish_patches(package);
4139         if (rc != ERROR_SUCCESS)
4140             goto end;
4141     }
4142
4143     /* FIXME: also need to publish if the product is in advertise mode */
4144     if (!msi_check_publish(package))
4145         return ERROR_SUCCESS;
4146
4147     rc = MSIREG_OpenProductKey(package->ProductCode, NULL, package->Context,
4148                                &hukey, TRUE);
4149     if (rc != ERROR_SUCCESS)
4150         goto end;
4151
4152     rc = MSIREG_OpenUserDataProductKey(package->ProductCode, package->Context,
4153                                        NULL, &hudkey, TRUE);
4154     if (rc != ERROR_SUCCESS)
4155         goto end;
4156
4157     rc = msi_publish_upgrade_code(package);
4158     if (rc != ERROR_SUCCESS)
4159         goto end;
4160
4161     rc = msi_publish_product_properties(package, hukey);
4162     if (rc != ERROR_SUCCESS)
4163         goto end;
4164
4165     rc = msi_publish_sourcelist(package, hukey);
4166     if (rc != ERROR_SUCCESS)
4167         goto end;
4168
4169     rc = msi_publish_icons(package);
4170
4171 end:
4172     uirow = MSI_CreateRecord( 1 );
4173     MSI_RecordSetStringW( uirow, 1, package->ProductCode );
4174     ui_actiondata( package, szPublishProduct, uirow );
4175     msiobj_release( &uirow->hdr );
4176
4177     RegCloseKey(hukey);
4178     RegCloseKey(hudkey);
4179
4180     return rc;
4181 }
4182
4183 static WCHAR *get_ini_file_name( MSIPACKAGE *package, MSIRECORD *row )
4184 {
4185     WCHAR *filename, *ptr, *folder, *ret;
4186     const WCHAR *dirprop;
4187
4188     filename = msi_dup_record_field( row, 2 );
4189     if (filename && (ptr = strchrW( filename, '|' )))
4190         ptr++;
4191     else
4192         ptr = filename;
4193
4194     dirprop = MSI_RecordGetString( row, 3 );
4195     if (dirprop)
4196     {
4197         folder = resolve_folder( package, dirprop, FALSE, FALSE, TRUE, NULL );
4198         if (!folder)
4199             folder = msi_dup_property( package->db, dirprop );
4200     }
4201     else
4202         folder = msi_dup_property( package->db, szWindowsFolder );
4203
4204     if (!folder)
4205     {
4206         ERR("Unable to resolve folder %s\n", debugstr_w(dirprop));
4207         msi_free( filename );
4208         return NULL;
4209     }
4210
4211     ret = build_directory_name( 2, folder, ptr );
4212
4213     msi_free( filename );
4214     msi_free( folder );
4215     return ret;
4216 }
4217
4218 static UINT ITERATE_WriteIniValues(MSIRECORD *row, LPVOID param)
4219 {
4220     MSIPACKAGE *package = param;
4221     LPCWSTR component, section, key, value, identifier;
4222     LPWSTR deformated_section, deformated_key, deformated_value, fullname;
4223     MSIRECORD * uirow;
4224     INT action;
4225     MSICOMPONENT *comp;
4226
4227     component = MSI_RecordGetString(row, 8);
4228     comp = get_loaded_component(package,component);
4229     if (!comp)
4230         return ERROR_SUCCESS;
4231
4232     if (!comp->Enabled)
4233     {
4234         TRACE("component is disabled\n");
4235         return ERROR_SUCCESS;
4236     }
4237
4238     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
4239     {
4240         TRACE("Component not scheduled for installation %s\n", debugstr_w(component));
4241         comp->Action = comp->Installed;
4242         return ERROR_SUCCESS;
4243     }
4244     comp->Action = INSTALLSTATE_LOCAL;
4245
4246     identifier = MSI_RecordGetString(row,1);
4247     section = MSI_RecordGetString(row,4);
4248     key = MSI_RecordGetString(row,5);
4249     value = MSI_RecordGetString(row,6);
4250     action = MSI_RecordGetInteger(row,7);
4251
4252     deformat_string(package,section,&deformated_section);
4253     deformat_string(package,key,&deformated_key);
4254     deformat_string(package,value,&deformated_value);
4255
4256     fullname = get_ini_file_name(package, row);
4257
4258     if (action == 0)
4259     {
4260         TRACE("Adding value %s to section %s in %s\n",
4261                 debugstr_w(deformated_key), debugstr_w(deformated_section),
4262                 debugstr_w(fullname));
4263         WritePrivateProfileStringW(deformated_section, deformated_key,
4264                                    deformated_value, fullname);
4265     }
4266     else if (action == 1)
4267     {
4268         WCHAR returned[10];
4269         GetPrivateProfileStringW(deformated_section, deformated_key, NULL,
4270                                  returned, 10, fullname);
4271         if (returned[0] == 0)
4272         {
4273             TRACE("Adding value %s to section %s in %s\n",
4274                     debugstr_w(deformated_key), debugstr_w(deformated_section),
4275                     debugstr_w(fullname));
4276
4277             WritePrivateProfileStringW(deformated_section, deformated_key,
4278                                        deformated_value, fullname);
4279         }
4280     }
4281     else if (action == 3)
4282         FIXME("Append to existing section not yet implemented\n");
4283
4284     uirow = MSI_CreateRecord(4);
4285     MSI_RecordSetStringW(uirow,1,identifier);
4286     MSI_RecordSetStringW(uirow,2,deformated_section);
4287     MSI_RecordSetStringW(uirow,3,deformated_key);
4288     MSI_RecordSetStringW(uirow,4,deformated_value);
4289     ui_actiondata(package,szWriteIniValues,uirow);
4290     msiobj_release( &uirow->hdr );
4291
4292     msi_free(fullname);
4293     msi_free(deformated_key);
4294     msi_free(deformated_value);
4295     msi_free(deformated_section);
4296     return ERROR_SUCCESS;
4297 }
4298
4299 static UINT ACTION_WriteIniValues(MSIPACKAGE *package)
4300 {
4301     UINT rc;
4302     MSIQUERY * view;
4303     static const WCHAR ExecSeqQuery[] =
4304         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4305          '`','I','n','i','F','i','l','e','`',0};
4306
4307     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4308     if (rc != ERROR_SUCCESS)
4309     {
4310         TRACE("no IniFile table\n");
4311         return ERROR_SUCCESS;
4312     }
4313
4314     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteIniValues, package);
4315     msiobj_release(&view->hdr);
4316     return rc;
4317 }
4318
4319 static UINT ITERATE_RemoveIniValuesOnUninstall( MSIRECORD *row, LPVOID param )
4320 {
4321     MSIPACKAGE *package = param;
4322     LPCWSTR component, section, key, value, identifier;
4323     LPWSTR deformated_section, deformated_key, deformated_value, filename;
4324     MSICOMPONENT *comp;
4325     MSIRECORD *uirow;
4326     INT action;
4327
4328     component = MSI_RecordGetString( row, 8 );
4329     comp = get_loaded_component( package, component );
4330     if (!comp)
4331         return ERROR_SUCCESS;
4332
4333     if (!comp->Enabled)
4334     {
4335         TRACE("component is disabled\n");
4336         return ERROR_SUCCESS;
4337     }
4338
4339     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
4340     {
4341         TRACE("Component not scheduled for removal %s\n", debugstr_w(component));
4342         comp->Action = comp->Installed;
4343         return ERROR_SUCCESS;
4344     }
4345     comp->Action = INSTALLSTATE_ABSENT;
4346
4347     identifier = MSI_RecordGetString( row, 1 );
4348     section = MSI_RecordGetString( row, 4 );
4349     key = MSI_RecordGetString( row, 5 );
4350     value = MSI_RecordGetString( row, 6 );
4351     action = MSI_RecordGetInteger( row, 7 );
4352
4353     deformat_string( package, section, &deformated_section );
4354     deformat_string( package, key, &deformated_key );
4355     deformat_string( package, value, &deformated_value );
4356
4357     if (action == msidbIniFileActionAddLine || action == msidbIniFileActionCreateLine)
4358     {
4359         filename = get_ini_file_name( package, row );
4360
4361         TRACE("Removing key %s from section %s in %s\n",
4362                debugstr_w(deformated_key), debugstr_w(deformated_section), debugstr_w(filename));
4363
4364         if (!WritePrivateProfileStringW( deformated_section, deformated_key, NULL, filename ))
4365         {
4366             WARN("Unable to remove key %u\n", GetLastError());
4367         }
4368         msi_free( filename );
4369     }
4370     else
4371         FIXME("Unsupported action %d\n", action);
4372
4373
4374     uirow = MSI_CreateRecord( 4 );
4375     MSI_RecordSetStringW( uirow, 1, identifier );
4376     MSI_RecordSetStringW( uirow, 2, deformated_section );
4377     MSI_RecordSetStringW( uirow, 3, deformated_key );
4378     MSI_RecordSetStringW( uirow, 4, deformated_value );
4379     ui_actiondata( package, szRemoveIniValues, uirow );
4380     msiobj_release( &uirow->hdr );
4381
4382     msi_free( deformated_key );
4383     msi_free( deformated_value );
4384     msi_free( deformated_section );
4385     return ERROR_SUCCESS;
4386 }
4387
4388 static UINT ITERATE_RemoveIniValuesOnInstall( MSIRECORD *row, LPVOID param )
4389 {
4390     MSIPACKAGE *package = param;
4391     LPCWSTR component, section, key, value, identifier;
4392     LPWSTR deformated_section, deformated_key, deformated_value, filename;
4393     MSICOMPONENT *comp;
4394     MSIRECORD *uirow;
4395     INT action;
4396
4397     component = MSI_RecordGetString( row, 8 );
4398     comp = get_loaded_component( package, component );
4399     if (!comp)
4400         return ERROR_SUCCESS;
4401
4402     if (!comp->Enabled)
4403     {
4404         TRACE("component is disabled\n");
4405         return ERROR_SUCCESS;
4406     }
4407
4408     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
4409     {
4410         TRACE("Component not scheduled for installation %s\n", debugstr_w(component));
4411         comp->Action = comp->Installed;
4412         return ERROR_SUCCESS;
4413     }
4414     comp->Action = INSTALLSTATE_LOCAL;
4415
4416     identifier = MSI_RecordGetString( row, 1 );
4417     section = MSI_RecordGetString( row, 4 );
4418     key = MSI_RecordGetString( row, 5 );
4419     value = MSI_RecordGetString( row, 6 );
4420     action = MSI_RecordGetInteger( row, 7 );
4421
4422     deformat_string( package, section, &deformated_section );
4423     deformat_string( package, key, &deformated_key );
4424     deformat_string( package, value, &deformated_value );
4425
4426     if (action == msidbIniFileActionRemoveLine)
4427     {
4428         filename = get_ini_file_name( package, row );
4429
4430         TRACE("Removing key %s from section %s in %s\n",
4431                debugstr_w(deformated_key), debugstr_w(deformated_section), debugstr_w(filename));
4432
4433         if (!WritePrivateProfileStringW( deformated_section, deformated_key, NULL, filename ))
4434         {
4435             WARN("Unable to remove key %u\n", GetLastError());
4436         }
4437         msi_free( filename );
4438     }
4439     else
4440         FIXME("Unsupported action %d\n", action);
4441
4442     uirow = MSI_CreateRecord( 4 );
4443     MSI_RecordSetStringW( uirow, 1, identifier );
4444     MSI_RecordSetStringW( uirow, 2, deformated_section );
4445     MSI_RecordSetStringW( uirow, 3, deformated_key );
4446     MSI_RecordSetStringW( uirow, 4, deformated_value );
4447     ui_actiondata( package, szRemoveIniValues, uirow );
4448     msiobj_release( &uirow->hdr );
4449
4450     msi_free( deformated_key );
4451     msi_free( deformated_value );
4452     msi_free( deformated_section );
4453     return ERROR_SUCCESS;
4454 }
4455
4456 static UINT ACTION_RemoveIniValues( MSIPACKAGE *package )
4457 {
4458     UINT rc;
4459     MSIQUERY *view;
4460     static const WCHAR query[] =
4461         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4462          '`','I','n','i','F','i','l','e','`',0};
4463     static const WCHAR remove_query[] =
4464         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4465          '`','R','e','m','o','v','e','I','n','i','F','i','l','e','`',0};
4466
4467     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
4468     if (rc == ERROR_SUCCESS)
4469     {
4470         rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveIniValuesOnUninstall, package );
4471         msiobj_release( &view->hdr );
4472         if (rc != ERROR_SUCCESS)
4473             return rc;
4474     }
4475
4476     rc = MSI_DatabaseOpenViewW( package->db, remove_query, &view );
4477     if (rc == ERROR_SUCCESS)
4478     {
4479         rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveIniValuesOnInstall, package );
4480         msiobj_release( &view->hdr );
4481         if (rc != ERROR_SUCCESS)
4482             return rc;
4483     }
4484
4485     return ERROR_SUCCESS;
4486 }
4487
4488 static void register_dll( const WCHAR *dll, BOOL unregister )
4489 {
4490     HMODULE hmod;
4491
4492     hmod = LoadLibraryExW( dll, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
4493     if (hmod)
4494     {
4495         HRESULT (WINAPI *func_ptr)( void );
4496         const char *func = unregister ? "DllUnregisterServer" : "DllRegisterServer";
4497
4498         func_ptr = (void *)GetProcAddress( hmod, func );
4499         if (func_ptr)
4500         {
4501             HRESULT hr = func_ptr();
4502             if (FAILED( hr ))
4503                 WARN("failed to register dll 0x%08x\n", hr);
4504         }
4505         else
4506             WARN("entry point %s not found\n", func);
4507         FreeLibrary( hmod );
4508         return;
4509     }
4510     WARN("failed to load library %u\n", GetLastError());
4511 }
4512
4513 static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
4514 {
4515     MSIPACKAGE *package = param;
4516     LPCWSTR filename;
4517     MSIFILE *file;
4518     MSIRECORD *uirow;
4519
4520     filename = MSI_RecordGetString(row,1);
4521     file = get_loaded_file( package, filename );
4522
4523     if (!file)
4524     {
4525         ERR("Unable to find file id %s\n",debugstr_w(filename));
4526         return ERROR_SUCCESS;
4527     }
4528
4529     TRACE("Registering %s\n", debugstr_w( file->TargetPath ));
4530
4531     register_dll( file->TargetPath, FALSE );
4532
4533     uirow = MSI_CreateRecord( 2 );
4534     MSI_RecordSetStringW( uirow, 1, filename );
4535     MSI_RecordSetStringW( uirow, 2, file->Component->Directory );
4536     ui_actiondata( package, szSelfRegModules, uirow );
4537     msiobj_release( &uirow->hdr );
4538
4539     return ERROR_SUCCESS;
4540 }
4541
4542 static UINT ACTION_SelfRegModules(MSIPACKAGE *package)
4543 {
4544     UINT rc;
4545     MSIQUERY * view;
4546     static const WCHAR ExecSeqQuery[] =
4547         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4548          '`','S','e','l','f','R','e','g','`',0};
4549
4550     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4551     if (rc != ERROR_SUCCESS)
4552     {
4553         TRACE("no SelfReg table\n");
4554         return ERROR_SUCCESS;
4555     }
4556
4557     MSI_IterateRecords(view, NULL, ITERATE_SelfRegModules, package);
4558     msiobj_release(&view->hdr);
4559
4560     return ERROR_SUCCESS;
4561 }
4562
4563 static UINT ITERATE_SelfUnregModules( MSIRECORD *row, LPVOID param )
4564 {
4565     MSIPACKAGE *package = param;
4566     LPCWSTR filename;
4567     MSIFILE *file;
4568     MSIRECORD *uirow;
4569
4570     filename = MSI_RecordGetString( row, 1 );
4571     file = get_loaded_file( package, filename );
4572
4573     if (!file)
4574     {
4575         ERR("Unable to find file id %s\n", debugstr_w(filename));
4576         return ERROR_SUCCESS;
4577     }
4578
4579     TRACE("Unregistering %s\n", debugstr_w( file->TargetPath ));
4580
4581     register_dll( file->TargetPath, TRUE );
4582
4583     uirow = MSI_CreateRecord( 2 );
4584     MSI_RecordSetStringW( uirow, 1, filename );
4585     MSI_RecordSetStringW( uirow, 2, file->Component->Directory );
4586     ui_actiondata( package, szSelfUnregModules, uirow );
4587     msiobj_release( &uirow->hdr );
4588
4589     return ERROR_SUCCESS;
4590 }
4591
4592 static UINT ACTION_SelfUnregModules( MSIPACKAGE *package )
4593 {
4594     UINT rc;
4595     MSIQUERY *view;
4596     static const WCHAR query[] =
4597         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4598          '`','S','e','l','f','R','e','g','`',0};
4599
4600     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
4601     if (rc != ERROR_SUCCESS)
4602     {
4603         TRACE("no SelfReg table\n");
4604         return ERROR_SUCCESS;
4605     }
4606
4607     MSI_IterateRecords( view, NULL, ITERATE_SelfUnregModules, package );
4608     msiobj_release( &view->hdr );
4609
4610     return ERROR_SUCCESS;
4611 }
4612
4613 static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
4614 {
4615     MSIFEATURE *feature;
4616     UINT rc;
4617     HKEY hkey = NULL, userdata = NULL;
4618
4619     if (!msi_check_publish(package))
4620         return ERROR_SUCCESS;
4621
4622     rc = MSIREG_OpenFeaturesKey(package->ProductCode, package->Context,
4623                                 &hkey, TRUE);
4624     if (rc != ERROR_SUCCESS)
4625         goto end;
4626
4627     rc = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, package->Context,
4628                                         &userdata, TRUE);
4629     if (rc != ERROR_SUCCESS)
4630         goto end;
4631
4632     /* here the guids are base 85 encoded */
4633     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
4634     {
4635         ComponentList *cl;
4636         LPWSTR data = NULL;
4637         GUID clsid;
4638         INT size;
4639         BOOL absent = FALSE;
4640         MSIRECORD *uirow;
4641
4642         if (feature->ActionRequest != INSTALLSTATE_LOCAL &&
4643             feature->ActionRequest != INSTALLSTATE_SOURCE &&
4644             feature->ActionRequest != INSTALLSTATE_ADVERTISED) absent = TRUE;
4645
4646         size = 1;
4647         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
4648         {
4649             size += 21;
4650         }
4651         if (feature->Feature_Parent)
4652             size += strlenW( feature->Feature_Parent )+2;
4653
4654         data = msi_alloc(size * sizeof(WCHAR));
4655
4656         data[0] = 0;
4657         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
4658         {
4659             MSICOMPONENT* component = cl->component;
4660             WCHAR buf[21];
4661
4662             buf[0] = 0;
4663             if (component->ComponentId)
4664             {
4665                 TRACE("From %s\n",debugstr_w(component->ComponentId));
4666                 CLSIDFromString(component->ComponentId, &clsid);
4667                 encode_base85_guid(&clsid,buf);
4668                 TRACE("to %s\n",debugstr_w(buf));
4669                 strcatW(data,buf);
4670             }
4671         }
4672
4673         if (feature->Feature_Parent)
4674         {
4675             static const WCHAR sep[] = {'\2',0};
4676             strcatW(data,sep);
4677             strcatW(data,feature->Feature_Parent);
4678         }
4679
4680         msi_reg_set_val_str( userdata, feature->Feature, data );
4681         msi_free(data);
4682
4683         size = 0;
4684         if (feature->Feature_Parent)
4685             size = strlenW(feature->Feature_Parent)*sizeof(WCHAR);
4686         if (!absent)
4687         {
4688             size += sizeof(WCHAR);
4689             RegSetValueExW(hkey,feature->Feature,0,REG_SZ,
4690                            (const BYTE*)(feature->Feature_Parent ? feature->Feature_Parent : szEmpty),size);
4691         }
4692         else
4693         {
4694             size += 2*sizeof(WCHAR);
4695             data = msi_alloc(size);
4696             data[0] = 0x6;
4697             data[1] = 0;
4698             if (feature->Feature_Parent)
4699                 strcpyW( &data[1], feature->Feature_Parent );
4700             RegSetValueExW(hkey,feature->Feature,0,REG_SZ,
4701                        (LPBYTE)data,size);
4702             msi_free(data);
4703         }
4704
4705         /* the UI chunk */
4706         uirow = MSI_CreateRecord( 1 );
4707         MSI_RecordSetStringW( uirow, 1, feature->Feature );
4708         ui_actiondata( package, szPublishFeatures, uirow);
4709         msiobj_release( &uirow->hdr );
4710         /* FIXME: call ui_progress? */
4711     }
4712
4713 end:
4714     RegCloseKey(hkey);
4715     RegCloseKey(userdata);
4716     return rc;
4717 }
4718
4719 static UINT msi_unpublish_feature(MSIPACKAGE *package, MSIFEATURE *feature)
4720 {
4721     UINT r;
4722     HKEY hkey;
4723     MSIRECORD *uirow;
4724
4725     TRACE("unpublishing feature %s\n", debugstr_w(feature->Feature));
4726
4727     r = MSIREG_OpenFeaturesKey(package->ProductCode, package->Context,
4728                                &hkey, FALSE);
4729     if (r == ERROR_SUCCESS)
4730     {
4731         RegDeleteValueW(hkey, feature->Feature);
4732         RegCloseKey(hkey);
4733     }
4734
4735     r = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, package->Context,
4736                                        &hkey, FALSE);
4737     if (r == ERROR_SUCCESS)
4738     {
4739         RegDeleteValueW(hkey, feature->Feature);
4740         RegCloseKey(hkey);
4741     }
4742
4743     uirow = MSI_CreateRecord( 1 );
4744     MSI_RecordSetStringW( uirow, 1, feature->Feature );
4745     ui_actiondata( package, szUnpublishFeatures, uirow );
4746     msiobj_release( &uirow->hdr );
4747
4748     return ERROR_SUCCESS;
4749 }
4750
4751 static UINT ACTION_UnpublishFeatures(MSIPACKAGE *package)
4752 {
4753     MSIFEATURE *feature;
4754
4755     if (!msi_check_unpublish(package))
4756         return ERROR_SUCCESS;
4757
4758     LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4759     {
4760         msi_unpublish_feature(package, feature);
4761     }
4762
4763     return ERROR_SUCCESS;
4764 }
4765
4766 static UINT msi_publish_install_properties(MSIPACKAGE *package, HKEY hkey)
4767 {
4768     SYSTEMTIME systime;
4769     DWORD size, langid;
4770     WCHAR date[9], *val, *buffer;
4771     const WCHAR *prop, *key;
4772
4773     static const WCHAR date_fmt[] = {'%','i','%','0','2','i','%','0','2','i',0};
4774     static const WCHAR szWindowsInstaller[] =
4775         {'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
4776     static const WCHAR modpath_fmt[] =
4777         {'M','s','i','E','x','e','c','.','e','x','e',' ',
4778          '/','I','[','P','r','o','d','u','c','t','C','o','d','e',']',0};
4779     static const WCHAR szModifyPath[] =
4780         {'M','o','d','i','f','y','P','a','t','h',0};
4781     static const WCHAR szUninstallString[] =
4782         {'U','n','i','n','s','t','a','l','l','S','t','r','i','n','g',0};
4783     static const WCHAR szEstimatedSize[] =
4784         {'E','s','t','i','m','a','t','e','d','S','i','z','e',0};
4785     static const WCHAR szProductLanguage[] =
4786         {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
4787     static const WCHAR szProductVersion[] =
4788         {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
4789     static const WCHAR szDisplayVersion[] =
4790         {'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0};
4791     static const WCHAR szInstallSource[] =
4792         {'I','n','s','t','a','l','l','S','o','u','r','c','e',0};
4793     static const WCHAR szARPAUTHORIZEDCDFPREFIX[] =
4794         {'A','R','P','A','U','T','H','O','R','I','Z','E','D','C','D','F','P','R','E','F','I','X',0};
4795     static const WCHAR szAuthorizedCDFPrefix[] =
4796         {'A','u','t','h','o','r','i','z','e','d','C','D','F','P','r','e','f','i','x',0};
4797     static const WCHAR szARPCONTACT[] =
4798         {'A','R','P','C','O','N','T','A','C','T',0};
4799     static const WCHAR szContact[] =
4800         {'C','o','n','t','a','c','t',0};
4801     static const WCHAR szARPCOMMENTS[] =
4802         {'A','R','P','C','O','M','M','E','N','T','S',0};
4803     static const WCHAR szComments[] =
4804         {'C','o','m','m','e','n','t','s',0};
4805     static const WCHAR szProductName[] =
4806         {'P','r','o','d','u','c','t','N','a','m','e',0};
4807     static const WCHAR szDisplayName[] =
4808         {'D','i','s','p','l','a','y','N','a','m','e',0};
4809     static const WCHAR szARPHELPLINK[] =
4810         {'A','R','P','H','E','L','P','L','I','N','K',0};
4811     static const WCHAR szHelpLink[] =
4812         {'H','e','l','p','L','i','n','k',0};
4813     static const WCHAR szARPHELPTELEPHONE[] =
4814         {'A','R','P','H','E','L','P','T','E','L','E','P','H','O','N','E',0};
4815     static const WCHAR szHelpTelephone[] =
4816         {'H','e','l','p','T','e','l','e','p','h','o','n','e',0};
4817     static const WCHAR szARPINSTALLLOCATION[] =
4818         {'A','R','P','I','N','S','T','A','L','L','L','O','C','A','T','I','O','N',0};
4819     static const WCHAR szInstallLocation[] =
4820         {'I','n','s','t','a','l','l','L','o','c','a','t','i','o','n',0};
4821     static const WCHAR szManufacturer[] =
4822         {'M','a','n','u','f','a','c','t','u','r','e','r',0};
4823     static const WCHAR szPublisher[] =
4824         {'P','u','b','l','i','s','h','e','r',0};
4825     static const WCHAR szARPREADME[] =
4826         {'A','R','P','R','E','A','D','M','E',0};
4827     static const WCHAR szReadme[] =
4828         {'R','e','a','d','M','e',0};
4829     static const WCHAR szARPSIZE[] =
4830         {'A','R','P','S','I','Z','E',0};
4831     static const WCHAR szSize[] =
4832         {'S','i','z','e',0};
4833     static const WCHAR szARPURLINFOABOUT[] =
4834         {'A','R','P','U','R','L','I','N','F','O','A','B','O','U','T',0};
4835     static const WCHAR szURLInfoAbout[] =
4836         {'U','R','L','I','n','f','o','A','b','o','u','t',0};
4837     static const WCHAR szARPURLUPDATEINFO[] =
4838         {'A','R','P','U','R','L','U','P','D','A','T','E','I','N','F','O',0};
4839     static const WCHAR szURLUpdateInfo[] =
4840         {'U','R','L','U','p','d','a','t','e','I','n','f','o',0};
4841
4842     static const WCHAR *propval[] = {
4843         szARPAUTHORIZEDCDFPREFIX, szAuthorizedCDFPrefix,
4844         szARPCONTACT,             szContact,
4845         szARPCOMMENTS,            szComments,
4846         szProductName,            szDisplayName,
4847         szARPHELPLINK,            szHelpLink,
4848         szARPHELPTELEPHONE,       szHelpTelephone,
4849         szARPINSTALLLOCATION,     szInstallLocation,
4850         cszSourceDir,             szInstallSource,
4851         szManufacturer,           szPublisher,
4852         szARPREADME,              szReadme,
4853         szARPSIZE,                szSize,
4854         szARPURLINFOABOUT,        szURLInfoAbout,
4855         szARPURLUPDATEINFO,       szURLUpdateInfo,
4856         NULL
4857     };
4858     const WCHAR **p = propval;
4859
4860     while (*p)
4861     {
4862         prop = *p++;
4863         key = *p++;
4864         val = msi_dup_property(package->db, prop);
4865         msi_reg_set_val_str(hkey, key, val);
4866         msi_free(val);
4867     }
4868
4869     msi_reg_set_val_dword(hkey, szWindowsInstaller, 1);
4870
4871     size = deformat_string(package, modpath_fmt, &buffer);
4872     RegSetValueExW(hkey, szModifyPath, 0, REG_EXPAND_SZ, (LPBYTE)buffer, size);
4873     RegSetValueExW(hkey, szUninstallString, 0, REG_EXPAND_SZ, (LPBYTE)buffer, size);
4874     msi_free(buffer);
4875
4876     /* FIXME: Write real Estimated Size when we have it */
4877     msi_reg_set_val_dword(hkey, szEstimatedSize, 0);
4878
4879     GetLocalTime(&systime);
4880     sprintfW(date, date_fmt, systime.wYear, systime.wMonth, systime.wDay);
4881     msi_reg_set_val_str(hkey, INSTALLPROPERTY_INSTALLDATEW, date);
4882
4883     langid = msi_get_property_int(package->db, szProductLanguage, 0);
4884     msi_reg_set_val_dword(hkey, INSTALLPROPERTY_LANGUAGEW, langid);
4885
4886     buffer = msi_dup_property(package->db, szProductVersion);
4887     msi_reg_set_val_str(hkey, szDisplayVersion, buffer);
4888     if (buffer)
4889     {
4890         DWORD verdword = msi_version_str_to_dword(buffer);
4891
4892         msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONW, verdword);
4893         msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword >> 24);
4894         msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword >> 16) & 0xFF);
4895         msi_free(buffer);
4896     }
4897
4898     return ERROR_SUCCESS;
4899 }
4900
4901 static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
4902 {
4903     WCHAR squashed_pc[SQUISH_GUID_SIZE];
4904     MSIRECORD *uirow;
4905     LPWSTR upgrade_code;
4906     HKEY hkey, props;
4907     HKEY upgrade;
4908     UINT rc;
4909
4910     /* FIXME: also need to publish if the product is in advertise mode */
4911     if (!msi_check_publish(package))
4912         return ERROR_SUCCESS;
4913
4914     rc = MSIREG_OpenUninstallKey(package, &hkey, TRUE);
4915     if (rc != ERROR_SUCCESS)
4916         return rc;
4917
4918     rc = MSIREG_OpenInstallProps(package->ProductCode, package->Context,
4919                                  NULL, &props, TRUE);
4920     if (rc != ERROR_SUCCESS)
4921         goto done;
4922
4923     msi_reg_set_val_str( props, INSTALLPROPERTY_LOCALPACKAGEW, package->db->localfile );
4924     msi_free( package->db->localfile );
4925     package->db->localfile = NULL;
4926
4927     rc = msi_publish_install_properties(package, hkey);
4928     if (rc != ERROR_SUCCESS)
4929         goto done;
4930
4931     rc = msi_publish_install_properties(package, props);
4932     if (rc != ERROR_SUCCESS)
4933         goto done;
4934
4935     upgrade_code = msi_dup_property(package->db, szUpgradeCode);
4936     if (upgrade_code)
4937     {
4938         MSIREG_OpenUpgradeCodesKey(upgrade_code, &upgrade, TRUE);
4939         squash_guid(package->ProductCode, squashed_pc);
4940         msi_reg_set_val_str(upgrade, squashed_pc, NULL);
4941         RegCloseKey(upgrade);
4942         msi_free(upgrade_code);
4943     }
4944
4945 done:
4946     uirow = MSI_CreateRecord( 1 );
4947     MSI_RecordSetStringW( uirow, 1, package->ProductCode );
4948     ui_actiondata( package, szRegisterProduct, uirow );
4949     msiobj_release( &uirow->hdr );
4950
4951     RegCloseKey(hkey);
4952     return ERROR_SUCCESS;
4953 }
4954
4955 static UINT ACTION_InstallExecute(MSIPACKAGE *package)
4956 {
4957     return execute_script(package,INSTALL_SCRIPT);
4958 }
4959
4960 static UINT msi_unpublish_product(MSIPACKAGE *package, WCHAR *remove)
4961 {
4962     WCHAR *upgrade, **features;
4963     BOOL full_uninstall = TRUE;
4964     MSIFEATURE *feature;
4965     MSIPATCHINFO *patch;
4966
4967     static const WCHAR szUpgradeCode[] =
4968         {'U','p','g','r','a','d','e','C','o','d','e',0};
4969
4970     features = msi_split_string(remove, ',');
4971     if (!features)
4972     {
4973         ERR("REMOVE feature list is empty!\n");
4974         return ERROR_FUNCTION_FAILED;
4975     }
4976
4977     if (!strcmpW( features[0], szAll ))
4978         full_uninstall = TRUE;
4979     else
4980     {
4981         LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4982         {
4983             if (feature->Action != INSTALLSTATE_ABSENT)
4984                 full_uninstall = FALSE;
4985         }
4986     }
4987     msi_free(features);
4988
4989     if (!full_uninstall)
4990         return ERROR_SUCCESS;
4991
4992     MSIREG_DeleteProductKey(package->ProductCode);
4993     MSIREG_DeleteUserDataProductKey(package->ProductCode);
4994     MSIREG_DeleteUninstallKey(package);
4995
4996     if (package->Context == MSIINSTALLCONTEXT_MACHINE)
4997     {
4998         MSIREG_DeleteLocalClassesProductKey(package->ProductCode);
4999         MSIREG_DeleteLocalClassesFeaturesKey(package->ProductCode);
5000     }
5001     else
5002     {
5003         MSIREG_DeleteUserProductKey(package->ProductCode);
5004         MSIREG_DeleteUserFeaturesKey(package->ProductCode);
5005     }
5006
5007     upgrade = msi_dup_property(package->db, szUpgradeCode);
5008     if (upgrade)
5009     {
5010         MSIREG_DeleteUserUpgradeCodesKey(upgrade);
5011         msi_free(upgrade);
5012     }
5013
5014     LIST_FOR_EACH_ENTRY(patch, &package->patches, MSIPATCHINFO, entry)
5015     {
5016         MSIREG_DeleteUserDataPatchKey(patch->patchcode, package->Context);
5017     }
5018
5019     return ERROR_SUCCESS;
5020 }
5021
5022 static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
5023 {
5024     UINT rc;
5025     WCHAR *remove;
5026
5027     /* turn off scheduling */
5028     package->script->CurrentlyScripting= FALSE;
5029
5030     /* first do the same as an InstallExecute */
5031     rc = ACTION_InstallExecute(package);
5032     if (rc != ERROR_SUCCESS)
5033         return rc;
5034
5035     /* then handle Commit Actions */
5036     rc = execute_script(package,COMMIT_SCRIPT);
5037     if (rc != ERROR_SUCCESS)
5038         return rc;
5039
5040     remove = msi_dup_property(package->db, szRemove);
5041     if (remove)
5042         rc = msi_unpublish_product(package, remove);
5043
5044     msi_free(remove);
5045     return rc;
5046 }
5047
5048 UINT ACTION_ForceReboot(MSIPACKAGE *package)
5049 {
5050     static const WCHAR RunOnce[] = {
5051     'S','o','f','t','w','a','r','e','\\',
5052     'M','i','c','r','o','s','o','f','t','\\',
5053     'W','i','n','d','o','w','s','\\',
5054     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
5055     'R','u','n','O','n','c','e',0};
5056     static const WCHAR InstallRunOnce[] = {
5057     'S','o','f','t','w','a','r','e','\\',
5058     'M','i','c','r','o','s','o','f','t','\\',
5059     'W','i','n','d','o','w','s','\\',
5060     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
5061     'I','n','s','t','a','l','l','e','r','\\',
5062     'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0};
5063
5064     static const WCHAR msiexec_fmt[] = {
5065     '%','s',
5066     '\\','M','s','i','E','x','e','c','.','e','x','e',' ','/','@',' ',
5067     '\"','%','s','\"',0};
5068     static const WCHAR install_fmt[] = {
5069     '/','I',' ','\"','%','s','\"',' ',
5070     'A','F','T','E','R','R','E','B','O','O','T','=','1',' ',
5071     'R','U','N','O','N','C','E','E','N','T','R','Y','=','\"','%','s','\"',0};
5072     WCHAR buffer[256], sysdir[MAX_PATH];
5073     HKEY hkey;
5074     WCHAR squished_pc[100];
5075
5076     squash_guid(package->ProductCode,squished_pc);
5077
5078     GetSystemDirectoryW(sysdir, sizeof(sysdir)/sizeof(sysdir[0]));
5079     RegCreateKeyW(HKEY_LOCAL_MACHINE,RunOnce,&hkey);
5080     snprintfW(buffer,sizeof(buffer)/sizeof(buffer[0]),msiexec_fmt,sysdir,
5081      squished_pc);
5082
5083     msi_reg_set_val_str( hkey, squished_pc, buffer );
5084     RegCloseKey(hkey);
5085
5086     TRACE("Reboot command %s\n",debugstr_w(buffer));
5087
5088     RegCreateKeyW(HKEY_LOCAL_MACHINE,InstallRunOnce,&hkey);
5089     sprintfW(buffer,install_fmt,package->ProductCode,squished_pc);
5090
5091     msi_reg_set_val_str( hkey, squished_pc, buffer );
5092     RegCloseKey(hkey);
5093
5094     return ERROR_INSTALL_SUSPEND;
5095 }
5096
5097 static UINT ACTION_ResolveSource(MSIPACKAGE* package)
5098 {
5099     DWORD attrib;
5100     UINT rc;
5101
5102     /*
5103      * We are currently doing what should be done here in the top level Install
5104      * however for Administrative and uninstalls this step will be needed
5105      */
5106     if (!package->PackagePath)
5107         return ERROR_SUCCESS;
5108
5109     msi_set_sourcedir_props(package, TRUE);
5110
5111     attrib = GetFileAttributesW(package->db->path);
5112     if (attrib == INVALID_FILE_ATTRIBUTES)
5113     {
5114         LPWSTR prompt;
5115         LPWSTR msg;
5116         DWORD size = 0;
5117
5118         rc = MsiSourceListGetInfoW(package->ProductCode, NULL,
5119                 package->Context, MSICODE_PRODUCT,
5120                 INSTALLPROPERTY_DISKPROMPTW,NULL,&size);
5121         if (rc == ERROR_MORE_DATA)
5122         {
5123             prompt = msi_alloc(size * sizeof(WCHAR));
5124             MsiSourceListGetInfoW(package->ProductCode, NULL,
5125                     package->Context, MSICODE_PRODUCT,
5126                     INSTALLPROPERTY_DISKPROMPTW,prompt,&size);
5127         }
5128         else
5129             prompt = strdupW(package->db->path);
5130
5131         msg = generate_error_string(package,1302,1,prompt);
5132         while(attrib == INVALID_FILE_ATTRIBUTES)
5133         {
5134             rc = MessageBoxW(NULL,msg,NULL,MB_OKCANCEL);
5135             if (rc == IDCANCEL)
5136             {
5137                 rc = ERROR_INSTALL_USEREXIT;
5138                 break;
5139             }
5140             attrib = GetFileAttributesW(package->db->path);
5141         }
5142         msi_free(prompt);
5143         rc = ERROR_SUCCESS;
5144     }
5145     else
5146         return ERROR_SUCCESS;
5147
5148     return rc;
5149 }
5150
5151 static UINT ACTION_RegisterUser(MSIPACKAGE *package)
5152 {
5153     HKEY hkey = 0;
5154     LPWSTR buffer, productid = NULL;
5155     UINT i, rc = ERROR_SUCCESS;
5156     MSIRECORD *uirow;
5157
5158     static const WCHAR szPropKeys[][80] =
5159     {
5160         {'P','r','o','d','u','c','t','I','D',0},
5161         {'U','S','E','R','N','A','M','E',0},
5162         {'C','O','M','P','A','N','Y','N','A','M','E',0},
5163         {0},
5164     };
5165
5166     static const WCHAR szRegKeys[][80] =
5167     {
5168         {'P','r','o','d','u','c','t','I','D',0},
5169         {'R','e','g','O','w','n','e','r',0},
5170         {'R','e','g','C','o','m','p','a','n','y',0},
5171         {0},
5172     };
5173
5174     if (msi_check_unpublish(package))
5175     {
5176         MSIREG_DeleteUserDataProductKey(package->ProductCode);
5177         goto end;
5178     }
5179
5180     productid = msi_dup_property( package->db, INSTALLPROPERTY_PRODUCTIDW );
5181     if (!productid)
5182         goto end;
5183
5184     rc = MSIREG_OpenInstallProps(package->ProductCode, package->Context,
5185                                  NULL, &hkey, TRUE);
5186     if (rc != ERROR_SUCCESS)
5187         goto end;
5188
5189     for( i = 0; szPropKeys[i][0]; i++ )
5190     {
5191         buffer = msi_dup_property( package->db, szPropKeys[i] );
5192         msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
5193         msi_free( buffer );
5194     }
5195
5196 end:
5197     uirow = MSI_CreateRecord( 1 );
5198     MSI_RecordSetStringW( uirow, 1, productid );
5199     ui_actiondata( package, szRegisterUser, uirow );
5200     msiobj_release( &uirow->hdr );
5201
5202     msi_free(productid);
5203     RegCloseKey(hkey);
5204     return rc;
5205 }
5206
5207
5208 static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
5209 {
5210     UINT rc;
5211
5212     package->script->InWhatSequence |= SEQUENCE_EXEC;
5213     rc = ACTION_ProcessExecSequence(package,FALSE);
5214     return rc;
5215 }
5216
5217
5218 static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
5219 {
5220     MSIPACKAGE *package = param;
5221     LPCWSTR compgroupid, component, feature, qualifier, text;
5222     LPWSTR advertise = NULL, output = NULL;
5223     HKEY hkey = NULL;
5224     UINT rc;
5225     MSICOMPONENT *comp;
5226     MSIFEATURE *feat;
5227     DWORD sz;
5228     MSIRECORD *uirow;
5229
5230     feature = MSI_RecordGetString(rec, 5);
5231     feat = get_loaded_feature(package, feature);
5232     if (!feat)
5233         return ERROR_SUCCESS;
5234
5235     if (feat->ActionRequest != INSTALLSTATE_LOCAL &&
5236         feat->ActionRequest != INSTALLSTATE_SOURCE &&
5237         feat->ActionRequest != INSTALLSTATE_ADVERTISED)
5238     {
5239         TRACE("Feature %s not scheduled for installation\n", debugstr_w(feature));
5240         feat->Action = feat->Installed;
5241         return ERROR_SUCCESS;
5242     }
5243
5244     component = MSI_RecordGetString(rec, 3);
5245     comp = get_loaded_component(package, component);
5246     if (!comp)
5247         return ERROR_SUCCESS;
5248
5249     compgroupid = MSI_RecordGetString(rec,1);
5250     qualifier = MSI_RecordGetString(rec,2);
5251
5252     rc = MSIREG_OpenUserComponentsKey(compgroupid, &hkey, TRUE);
5253     if (rc != ERROR_SUCCESS)
5254         goto end;
5255
5256     text = MSI_RecordGetString(rec,4);
5257     advertise = create_component_advertise_string(package, comp, feature);
5258
5259     sz = strlenW(advertise);
5260
5261     if (text)
5262         sz += lstrlenW(text);
5263
5264     sz+=3;
5265     sz *= sizeof(WCHAR);
5266
5267     output = msi_alloc_zero(sz);
5268     strcpyW(output,advertise);
5269     msi_free(advertise);
5270
5271     if (text)
5272         strcatW(output,text);
5273
5274     msi_reg_set_val_multi_str( hkey, qualifier, output );
5275
5276 end:
5277     RegCloseKey(hkey);
5278     msi_free(output);
5279
5280     /* the UI chunk */
5281     uirow = MSI_CreateRecord( 2 );
5282     MSI_RecordSetStringW( uirow, 1, compgroupid );
5283     MSI_RecordSetStringW( uirow, 2, qualifier);
5284     ui_actiondata( package, szPublishComponents, uirow);
5285     msiobj_release( &uirow->hdr );
5286     /* FIXME: call ui_progress? */
5287
5288     return rc;
5289 }
5290
5291 /*
5292  * At present I am ignorning the advertised components part of this and only
5293  * focusing on the qualified component sets
5294  */
5295 static UINT ACTION_PublishComponents(MSIPACKAGE *package)
5296 {
5297     UINT rc;
5298     MSIQUERY * view;
5299     static const WCHAR ExecSeqQuery[] =
5300         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5301          '`','P','u','b','l','i','s','h',
5302          'C','o','m','p','o','n','e','n','t','`',0};
5303
5304     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5305     if (rc != ERROR_SUCCESS)
5306         return ERROR_SUCCESS;
5307
5308     rc = MSI_IterateRecords(view, NULL, ITERATE_PublishComponent, package);
5309     msiobj_release(&view->hdr);
5310
5311     return rc;
5312 }
5313
5314 static UINT ITERATE_UnpublishComponent( MSIRECORD *rec, LPVOID param )
5315 {
5316     static const WCHAR szInstallerComponents[] = {
5317         'S','o','f','t','w','a','r','e','\\',
5318         'M','i','c','r','o','s','o','f','t','\\',
5319         'I','n','s','t','a','l','l','e','r','\\',
5320         'C','o','m','p','o','n','e','n','t','s','\\',0};
5321
5322     MSIPACKAGE *package = param;
5323     LPCWSTR compgroupid, component, feature, qualifier;
5324     MSICOMPONENT *comp;
5325     MSIFEATURE *feat;
5326     MSIRECORD *uirow;
5327     WCHAR squashed[GUID_SIZE], keypath[MAX_PATH];
5328     LONG res;
5329
5330     feature = MSI_RecordGetString( rec, 5 );
5331     feat = get_loaded_feature( package, feature );
5332     if (!feat)
5333         return ERROR_SUCCESS;
5334
5335     if (feat->ActionRequest != INSTALLSTATE_ABSENT)
5336     {
5337         TRACE("Feature %s not scheduled for removal\n", debugstr_w(feature));
5338         feat->Action = feat->Installed;
5339         return ERROR_SUCCESS;
5340     }
5341
5342     component = MSI_RecordGetString( rec, 3 );
5343     comp = get_loaded_component( package, component );
5344     if (!comp)
5345         return ERROR_SUCCESS;
5346
5347     compgroupid = MSI_RecordGetString( rec, 1 );
5348     qualifier = MSI_RecordGetString( rec, 2 );
5349
5350     squash_guid( compgroupid, squashed );
5351     strcpyW( keypath, szInstallerComponents );
5352     strcatW( keypath, squashed );
5353
5354     res = RegDeleteKeyW( HKEY_CURRENT_USER, keypath );
5355     if (res != ERROR_SUCCESS)
5356     {
5357         WARN("Unable to delete component key %d\n", res);
5358     }
5359
5360     uirow = MSI_CreateRecord( 2 );
5361     MSI_RecordSetStringW( uirow, 1, compgroupid );
5362     MSI_RecordSetStringW( uirow, 2, qualifier );
5363     ui_actiondata( package, szUnpublishComponents, uirow );
5364     msiobj_release( &uirow->hdr );
5365
5366     return ERROR_SUCCESS;
5367 }
5368
5369 static UINT ACTION_UnpublishComponents( MSIPACKAGE *package )
5370 {
5371     UINT rc;
5372     MSIQUERY *view;
5373     static const WCHAR query[] =
5374         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5375          '`','P','u','b','l','i','s','h',
5376          'C','o','m','p','o','n','e','n','t','`',0};
5377
5378     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
5379     if (rc != ERROR_SUCCESS)
5380         return ERROR_SUCCESS;
5381
5382     rc = MSI_IterateRecords( view, NULL, ITERATE_UnpublishComponent, package );
5383     msiobj_release( &view->hdr );
5384
5385     return rc;
5386 }
5387
5388 static UINT ITERATE_InstallService(MSIRECORD *rec, LPVOID param)
5389 {
5390     MSIPACKAGE *package = param;
5391     MSIRECORD *row;
5392     MSIFILE *file;
5393     SC_HANDLE hscm, service = NULL;
5394     LPCWSTR comp, key;
5395     LPWSTR name = NULL, disp = NULL, load_order = NULL, serv_name = NULL;
5396     LPWSTR depends = NULL, pass = NULL, args = NULL, image_path = NULL;
5397     DWORD serv_type, start_type, err_control;
5398     SERVICE_DESCRIPTIONW sd = {NULL};
5399
5400     static const WCHAR query[] =
5401         {'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
5402          '`','C','o','m','p','o','n','e','n','t','`',' ',
5403          'W','H','E','R','E',' ',
5404          '`','C','o','m','p','o','n','e','n','t','`',' ',
5405          '=','\'','%','s','\'',0};
5406
5407     hscm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, GENERIC_WRITE);
5408     if (!hscm)
5409     {
5410         ERR("Failed to open the SC Manager!\n");
5411         goto done;
5412     }
5413
5414     start_type = MSI_RecordGetInteger(rec, 5);
5415     if (start_type == SERVICE_BOOT_START || start_type == SERVICE_SYSTEM_START)
5416         goto done;
5417
5418     deformat_string(package, MSI_RecordGetString(rec, 2), &name);
5419     deformat_string(package, MSI_RecordGetString(rec, 3), &disp);
5420     serv_type = MSI_RecordGetInteger(rec, 4);
5421     err_control = MSI_RecordGetInteger(rec, 6);
5422     deformat_string(package, MSI_RecordGetString(rec, 7), &load_order);
5423     deformat_string(package, MSI_RecordGetString(rec, 8), &depends);
5424     deformat_string(package, MSI_RecordGetString(rec, 9), &serv_name);
5425     deformat_string(package, MSI_RecordGetString(rec, 10), &pass);
5426     deformat_string(package, MSI_RecordGetString(rec, 11), &args);
5427     comp = MSI_RecordGetString(rec, 12);
5428     deformat_string(package, MSI_RecordGetString(rec, 13), &sd.lpDescription);
5429
5430     /* fetch the service path */
5431     row = MSI_QueryGetRecord(package->db, query, comp);
5432     if (!row)
5433     {
5434         ERR("Control query failed!\n");
5435         goto done;
5436     }
5437     key = MSI_RecordGetString(row, 6);
5438
5439     file = get_loaded_file(package, key);
5440     msiobj_release(&row->hdr);
5441     if (!file)
5442     {
5443         ERR("Failed to load the service file\n");
5444         goto done;
5445     }
5446
5447     if (!args || !args[0]) image_path = file->TargetPath;
5448     else
5449     {
5450         int len = strlenW(file->TargetPath) + strlenW(args) + 2;
5451         if (!(image_path = msi_alloc(len * sizeof(WCHAR))))
5452             return ERROR_OUTOFMEMORY;
5453
5454         strcpyW(image_path, file->TargetPath);
5455         strcatW(image_path, szSpace);
5456         strcatW(image_path, args);
5457     }
5458     service = CreateServiceW(hscm, name, disp, GENERIC_ALL, serv_type,
5459                              start_type, err_control, image_path, load_order,
5460                              NULL, depends, serv_name, pass);
5461
5462     if (!service)
5463     {
5464         if (GetLastError() != ERROR_SERVICE_EXISTS)
5465             ERR("Failed to create service %s: %d\n", debugstr_w(name), GetLastError());
5466     }
5467     else if (sd.lpDescription)
5468     {
5469         if (!ChangeServiceConfig2W(service, SERVICE_CONFIG_DESCRIPTION, &sd))
5470             WARN("failed to set service description %u\n", GetLastError());
5471     }
5472
5473     if (image_path != file->TargetPath) msi_free(image_path);
5474 done:
5475     CloseServiceHandle(service);
5476     CloseServiceHandle(hscm);
5477     msi_free(name);
5478     msi_free(disp);
5479     msi_free(sd.lpDescription);
5480     msi_free(load_order);
5481     msi_free(serv_name);
5482     msi_free(pass);
5483     msi_free(depends);
5484     msi_free(args);
5485
5486     return ERROR_SUCCESS;
5487 }
5488
5489 static UINT ACTION_InstallServices( MSIPACKAGE *package )
5490 {
5491     UINT rc;
5492     MSIQUERY * view;
5493     static const WCHAR ExecSeqQuery[] =
5494         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5495          'S','e','r','v','i','c','e','I','n','s','t','a','l','l',0};
5496
5497     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5498     if (rc != ERROR_SUCCESS)
5499         return ERROR_SUCCESS;
5500
5501     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallService, package);
5502     msiobj_release(&view->hdr);
5503
5504     return rc;
5505 }
5506
5507 /* converts arg1[~]arg2[~]arg3 to a list of ptrs to the strings */
5508 static LPCWSTR *msi_service_args_to_vector(LPWSTR args, DWORD *numargs)
5509 {
5510     LPCWSTR *vector, *temp_vector;
5511     LPWSTR p, q;
5512     DWORD sep_len;
5513
5514     static const WCHAR separator[] = {'[','~',']',0};
5515
5516     *numargs = 0;
5517     sep_len = sizeof(separator) / sizeof(WCHAR) - 1;
5518
5519     if (!args)
5520         return NULL;
5521
5522     vector = msi_alloc(sizeof(LPWSTR));
5523     if (!vector)
5524         return NULL;
5525
5526     p = args;
5527     do
5528     {
5529         (*numargs)++;
5530         vector[*numargs - 1] = p;
5531
5532         if ((q = strstrW(p, separator)))
5533         {
5534             *q = '\0';
5535
5536             temp_vector = msi_realloc(vector, (*numargs + 1) * sizeof(LPWSTR));
5537             if (!temp_vector)
5538             {
5539                 msi_free(vector);
5540                 return NULL;
5541             }
5542             vector = temp_vector;
5543
5544             p = q + sep_len;
5545         }
5546     } while (q);
5547
5548     return vector;
5549 }
5550
5551 static UINT ITERATE_StartService(MSIRECORD *rec, LPVOID param)
5552 {
5553     MSIPACKAGE *package = param;
5554     MSICOMPONENT *comp;
5555     MSIRECORD *uirow;
5556     SC_HANDLE scm = NULL, service = NULL;
5557     LPCWSTR component, *vector = NULL;
5558     LPWSTR name, args, display_name = NULL;
5559     DWORD event, numargs, len;
5560     UINT r = ERROR_FUNCTION_FAILED;
5561
5562     component = MSI_RecordGetString(rec, 6);
5563     comp = get_loaded_component(package, component);
5564     if (!comp)
5565         return ERROR_SUCCESS;
5566
5567     if (!comp->Enabled)
5568     {
5569         TRACE("component is disabled\n");
5570         return ERROR_SUCCESS;
5571     }
5572
5573     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
5574     {
5575         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
5576         comp->Action = comp->Installed;
5577         return ERROR_SUCCESS;
5578     }
5579     comp->Action = INSTALLSTATE_LOCAL;
5580
5581     deformat_string(package, MSI_RecordGetString(rec, 2), &name);
5582     deformat_string(package, MSI_RecordGetString(rec, 4), &args);
5583     event = MSI_RecordGetInteger(rec, 3);
5584
5585     if (!(event & msidbServiceControlEventStart))
5586     {
5587         r = ERROR_SUCCESS;
5588         goto done;
5589     }
5590
5591     scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
5592     if (!scm)
5593     {
5594         ERR("Failed to open the service control manager\n");
5595         goto done;
5596     }
5597
5598     len = 0;
5599     if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
5600         GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5601     {
5602         if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
5603             GetServiceDisplayNameW( scm, name, display_name, &len );
5604     }
5605
5606     service = OpenServiceW(scm, name, SERVICE_START);
5607     if (!service)
5608     {
5609         ERR("Failed to open service %s (%u)\n", debugstr_w(name), GetLastError());
5610         goto done;
5611     }
5612
5613     vector = msi_service_args_to_vector(args, &numargs);
5614
5615     if (!StartServiceW(service, numargs, vector) &&
5616         GetLastError() != ERROR_SERVICE_ALREADY_RUNNING)
5617     {
5618         ERR("Failed to start service %s (%u)\n", debugstr_w(name), GetLastError());
5619         goto done;
5620     }
5621
5622     r = ERROR_SUCCESS;
5623
5624 done:
5625     uirow = MSI_CreateRecord( 2 );
5626     MSI_RecordSetStringW( uirow, 1, display_name );
5627     MSI_RecordSetStringW( uirow, 2, name );
5628     ui_actiondata( package, szStartServices, uirow );
5629     msiobj_release( &uirow->hdr );
5630
5631     CloseServiceHandle(service);
5632     CloseServiceHandle(scm);
5633
5634     msi_free(name);
5635     msi_free(args);
5636     msi_free(vector);
5637     msi_free(display_name);
5638     return r;
5639 }
5640
5641 static UINT ACTION_StartServices( MSIPACKAGE *package )
5642 {
5643     UINT rc;
5644     MSIQUERY *view;
5645
5646     static const WCHAR query[] = {
5647         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5648         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
5649
5650     rc = MSI_DatabaseOpenViewW(package->db, query, &view);
5651     if (rc != ERROR_SUCCESS)
5652         return ERROR_SUCCESS;
5653
5654     rc = MSI_IterateRecords(view, NULL, ITERATE_StartService, package);
5655     msiobj_release(&view->hdr);
5656
5657     return rc;
5658 }
5659
5660 static BOOL stop_service_dependents(SC_HANDLE scm, SC_HANDLE service)
5661 {
5662     DWORD i, needed, count;
5663     ENUM_SERVICE_STATUSW *dependencies;
5664     SERVICE_STATUS ss;
5665     SC_HANDLE depserv;
5666
5667     if (EnumDependentServicesW(service, SERVICE_ACTIVE, NULL,
5668                                0, &needed, &count))
5669         return TRUE;
5670
5671     if (GetLastError() != ERROR_MORE_DATA)
5672         return FALSE;
5673
5674     dependencies = msi_alloc(needed);
5675     if (!dependencies)
5676         return FALSE;
5677
5678     if (!EnumDependentServicesW(service, SERVICE_ACTIVE, dependencies,
5679                                 needed, &needed, &count))
5680         goto error;
5681
5682     for (i = 0; i < count; i++)
5683     {
5684         depserv = OpenServiceW(scm, dependencies[i].lpServiceName,
5685                                SERVICE_STOP | SERVICE_QUERY_STATUS);
5686         if (!depserv)
5687             goto error;
5688
5689         if (!ControlService(depserv, SERVICE_CONTROL_STOP, &ss))
5690             goto error;
5691     }
5692
5693     return TRUE;
5694
5695 error:
5696     msi_free(dependencies);
5697     return FALSE;
5698 }
5699
5700 static UINT stop_service( LPCWSTR name )
5701 {
5702     SC_HANDLE scm = NULL, service = NULL;
5703     SERVICE_STATUS status;
5704     SERVICE_STATUS_PROCESS ssp;
5705     DWORD needed;
5706
5707     scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
5708     if (!scm)
5709     {
5710         WARN("Failed to open the SCM: %d\n", GetLastError());
5711         goto done;
5712     }
5713
5714     service = OpenServiceW(scm, name,
5715                            SERVICE_STOP |
5716                            SERVICE_QUERY_STATUS |
5717                            SERVICE_ENUMERATE_DEPENDENTS);
5718     if (!service)
5719     {
5720         WARN("Failed to open service (%s): %d\n", debugstr_w(name), GetLastError());
5721         goto done;
5722     }
5723
5724     if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp,
5725                               sizeof(SERVICE_STATUS_PROCESS), &needed))
5726     {
5727         WARN("Failed to query service status (%s): %d\n", debugstr_w(name), GetLastError());
5728         goto done;
5729     }
5730
5731     if (ssp.dwCurrentState == SERVICE_STOPPED)
5732         goto done;
5733
5734     stop_service_dependents(scm, service);
5735
5736     if (!ControlService(service, SERVICE_CONTROL_STOP, &status))
5737         WARN("Failed to stop service (%s): %d\n", debugstr_w(name), GetLastError());
5738
5739 done:
5740     CloseServiceHandle(service);
5741     CloseServiceHandle(scm);
5742
5743     return ERROR_SUCCESS;
5744 }
5745
5746 static UINT ITERATE_StopService( MSIRECORD *rec, LPVOID param )
5747 {
5748     MSIPACKAGE *package = param;
5749     MSICOMPONENT *comp;
5750     MSIRECORD *uirow;
5751     LPCWSTR component;
5752     LPWSTR name = NULL, display_name = NULL;
5753     DWORD event, len;
5754     SC_HANDLE scm;
5755
5756     event = MSI_RecordGetInteger( rec, 3 );
5757     if (!(event & msidbServiceControlEventStop))
5758         return ERROR_SUCCESS;
5759
5760     component = MSI_RecordGetString( rec, 6 );
5761     comp = get_loaded_component( package, component );
5762     if (!comp)
5763         return ERROR_SUCCESS;
5764
5765     if (!comp->Enabled)
5766     {
5767         TRACE("component is disabled\n");
5768         return ERROR_SUCCESS;
5769     }
5770
5771     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
5772     {
5773         TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
5774         comp->Action = comp->Installed;
5775         return ERROR_SUCCESS;
5776     }
5777     comp->Action = INSTALLSTATE_ABSENT;
5778
5779     scm = OpenSCManagerW( NULL, NULL, SC_MANAGER_CONNECT );
5780     if (!scm)
5781     {
5782         ERR("Failed to open the service control manager\n");
5783         goto done;
5784     }
5785
5786     len = 0;
5787     if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
5788         GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5789     {
5790         if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
5791             GetServiceDisplayNameW( scm, name, display_name, &len );
5792     }
5793     CloseServiceHandle( scm );
5794
5795     deformat_string( package, MSI_RecordGetString( rec, 2 ), &name );
5796     stop_service( name );
5797
5798 done:
5799     uirow = MSI_CreateRecord( 2 );
5800     MSI_RecordSetStringW( uirow, 1, display_name );
5801     MSI_RecordSetStringW( uirow, 2, name );
5802     ui_actiondata( package, szStopServices, uirow );
5803     msiobj_release( &uirow->hdr );
5804
5805     msi_free( name );
5806     msi_free( display_name );
5807     return ERROR_SUCCESS;
5808 }
5809
5810 static UINT ACTION_StopServices( MSIPACKAGE *package )
5811 {
5812     UINT rc;
5813     MSIQUERY *view;
5814
5815     static const WCHAR query[] = {
5816         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5817         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
5818
5819     rc = MSI_DatabaseOpenViewW(package->db, query, &view);
5820     if (rc != ERROR_SUCCESS)
5821         return ERROR_SUCCESS;
5822
5823     rc = MSI_IterateRecords(view, NULL, ITERATE_StopService, package);
5824     msiobj_release(&view->hdr);
5825
5826     return rc;
5827 }
5828
5829 static UINT ITERATE_DeleteService( MSIRECORD *rec, LPVOID param )
5830 {
5831     MSIPACKAGE *package = param;
5832     MSICOMPONENT *comp;
5833     MSIRECORD *uirow;
5834     LPCWSTR component;
5835     LPWSTR name = NULL, display_name = NULL;
5836     DWORD event, len;
5837     SC_HANDLE scm = NULL, service = NULL;
5838
5839     event = MSI_RecordGetInteger( rec, 3 );
5840     if (!(event & msidbServiceControlEventDelete))
5841         return ERROR_SUCCESS;
5842
5843     component = MSI_RecordGetString(rec, 6);
5844     comp = get_loaded_component(package, component);
5845     if (!comp)
5846         return ERROR_SUCCESS;
5847
5848     if (!comp->Enabled)
5849     {
5850         TRACE("component is disabled\n");
5851         return ERROR_SUCCESS;
5852     }
5853
5854     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
5855     {
5856         TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
5857         comp->Action = comp->Installed;
5858         return ERROR_SUCCESS;
5859     }
5860     comp->Action = INSTALLSTATE_ABSENT;
5861
5862     deformat_string( package, MSI_RecordGetString(rec, 2), &name );
5863     stop_service( name );
5864
5865     scm = OpenSCManagerW( NULL, NULL, SC_MANAGER_ALL_ACCESS );
5866     if (!scm)
5867     {
5868         WARN("Failed to open the SCM: %d\n", GetLastError());
5869         goto done;
5870     }
5871
5872     len = 0;
5873     if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
5874         GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5875     {
5876         if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
5877             GetServiceDisplayNameW( scm, name, display_name, &len );
5878     }
5879
5880     service = OpenServiceW( scm, name, DELETE );
5881     if (!service)
5882     {
5883         WARN("Failed to open service (%s): %u\n", debugstr_w(name), GetLastError());
5884         goto done;
5885     }
5886
5887     if (!DeleteService( service ))
5888         WARN("Failed to delete service (%s): %u\n", debugstr_w(name), GetLastError());
5889
5890 done:
5891     uirow = MSI_CreateRecord( 2 );
5892     MSI_RecordSetStringW( uirow, 1, display_name );
5893     MSI_RecordSetStringW( uirow, 2, name );
5894     ui_actiondata( package, szDeleteServices, uirow );
5895     msiobj_release( &uirow->hdr );
5896
5897     CloseServiceHandle( service );
5898     CloseServiceHandle( scm );
5899     msi_free( name );
5900     msi_free( display_name );
5901
5902     return ERROR_SUCCESS;
5903 }
5904
5905 static UINT ACTION_DeleteServices( MSIPACKAGE *package )
5906 {
5907     UINT rc;
5908     MSIQUERY *view;
5909
5910     static const WCHAR query[] = {
5911         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5912         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
5913
5914     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
5915     if (rc != ERROR_SUCCESS)
5916         return ERROR_SUCCESS;
5917
5918     rc = MSI_IterateRecords( view, NULL, ITERATE_DeleteService, package );
5919     msiobj_release( &view->hdr );
5920
5921     return rc;
5922 }
5923
5924 static UINT ITERATE_InstallODBCDriver( MSIRECORD *rec, LPVOID param )
5925 {
5926     MSIPACKAGE *package = param;
5927     LPWSTR driver, driver_path, ptr;
5928     WCHAR outpath[MAX_PATH];
5929     MSIFILE *driver_file = NULL, *setup_file = NULL;
5930     MSIRECORD *uirow;
5931     LPCWSTR desc, file_key;
5932     DWORD len, usage;
5933     UINT r = ERROR_SUCCESS;
5934
5935     static const WCHAR driver_fmt[] = {
5936         'D','r','i','v','e','r','=','%','s',0};
5937     static const WCHAR setup_fmt[] = {
5938         'S','e','t','u','p','=','%','s',0};
5939     static const WCHAR usage_fmt[] = {
5940         'F','i','l','e','U','s','a','g','e','=','1',0};
5941
5942     desc = MSI_RecordGetString(rec, 3);
5943
5944     file_key = MSI_RecordGetString( rec, 4 );
5945     if (file_key) driver_file = get_loaded_file( package, file_key );
5946
5947     file_key = MSI_RecordGetString( rec, 5 );
5948     if (file_key) setup_file = get_loaded_file( package, file_key );
5949
5950     if (!driver_file)
5951     {
5952         ERR("ODBC Driver entry not found!\n");
5953         return ERROR_FUNCTION_FAILED;
5954     }
5955
5956     len = lstrlenW(desc) + lstrlenW(driver_fmt) + lstrlenW(driver_file->FileName);
5957     if (setup_file)
5958         len += lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName);
5959     len += lstrlenW(usage_fmt) + 2; /* \0\0 */
5960
5961     driver = msi_alloc(len * sizeof(WCHAR));
5962     if (!driver)
5963         return ERROR_OUTOFMEMORY;
5964
5965     ptr = driver;
5966     lstrcpyW(ptr, desc);
5967     ptr += lstrlenW(ptr) + 1;
5968
5969     len = sprintfW(ptr, driver_fmt, driver_file->FileName);
5970     ptr += len + 1;
5971
5972     if (setup_file)
5973     {
5974         len = sprintfW(ptr, setup_fmt, setup_file->FileName);
5975         ptr += len + 1;
5976     }
5977
5978     lstrcpyW(ptr, usage_fmt);
5979     ptr += lstrlenW(ptr) + 1;
5980     *ptr = '\0';
5981
5982     driver_path = strdupW(driver_file->TargetPath);
5983     ptr = strrchrW(driver_path, '\\');
5984     if (ptr) *ptr = '\0';
5985
5986     if (!SQLInstallDriverExW(driver, driver_path, outpath, MAX_PATH,
5987                              NULL, ODBC_INSTALL_COMPLETE, &usage))
5988     {
5989         ERR("Failed to install SQL driver!\n");
5990         r = ERROR_FUNCTION_FAILED;
5991     }
5992
5993     uirow = MSI_CreateRecord( 5 );
5994     MSI_RecordSetStringW( uirow, 1, desc );
5995     MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
5996     MSI_RecordSetStringW( uirow, 3, driver_file->Component->Directory );
5997     ui_actiondata( package, szInstallODBC, uirow );
5998     msiobj_release( &uirow->hdr );
5999
6000     msi_free(driver);
6001     msi_free(driver_path);
6002
6003     return r;
6004 }
6005
6006 static UINT ITERATE_InstallODBCTranslator( MSIRECORD *rec, LPVOID param )
6007 {
6008     MSIPACKAGE *package = param;
6009     LPWSTR translator, translator_path, ptr;
6010     WCHAR outpath[MAX_PATH];
6011     MSIFILE *translator_file = NULL, *setup_file = NULL;
6012     MSIRECORD *uirow;
6013     LPCWSTR desc, file_key;
6014     DWORD len, usage;
6015     UINT r = ERROR_SUCCESS;
6016
6017     static const WCHAR translator_fmt[] = {
6018         'T','r','a','n','s','l','a','t','o','r','=','%','s',0};
6019     static const WCHAR setup_fmt[] = {
6020         'S','e','t','u','p','=','%','s',0};
6021
6022     desc = MSI_RecordGetString(rec, 3);
6023
6024     file_key = MSI_RecordGetString( rec, 4 );
6025     if (file_key) translator_file = get_loaded_file( package, file_key );
6026
6027     file_key = MSI_RecordGetString( rec, 5 );
6028     if (file_key) setup_file = get_loaded_file( package, file_key );
6029
6030     if (!translator_file)
6031     {
6032         ERR("ODBC Translator entry not found!\n");
6033         return ERROR_FUNCTION_FAILED;
6034     }
6035
6036     len = lstrlenW(desc) + lstrlenW(translator_fmt) + lstrlenW(translator_file->FileName) + 2; /* \0\0 */
6037     if (setup_file)
6038         len += lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName);
6039
6040     translator = msi_alloc(len * sizeof(WCHAR));
6041     if (!translator)
6042         return ERROR_OUTOFMEMORY;
6043
6044     ptr = translator;
6045     lstrcpyW(ptr, desc);
6046     ptr += lstrlenW(ptr) + 1;
6047
6048     len = sprintfW(ptr, translator_fmt, translator_file->FileName);
6049     ptr += len + 1;
6050
6051     if (setup_file)
6052     {
6053         len = sprintfW(ptr, setup_fmt, setup_file->FileName);
6054         ptr += len + 1;
6055     }
6056     *ptr = '\0';
6057
6058     translator_path = strdupW(translator_file->TargetPath);
6059     ptr = strrchrW(translator_path, '\\');
6060     if (ptr) *ptr = '\0';
6061
6062     if (!SQLInstallTranslatorExW(translator, translator_path, outpath, MAX_PATH,
6063                                  NULL, ODBC_INSTALL_COMPLETE, &usage))
6064     {
6065         ERR("Failed to install SQL translator!\n");
6066         r = ERROR_FUNCTION_FAILED;
6067     }
6068
6069     uirow = MSI_CreateRecord( 5 );
6070     MSI_RecordSetStringW( uirow, 1, desc );
6071     MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6072     MSI_RecordSetStringW( uirow, 3, translator_file->Component->Directory );
6073     ui_actiondata( package, szInstallODBC, uirow );
6074     msiobj_release( &uirow->hdr );
6075
6076     msi_free(translator);
6077     msi_free(translator_path);
6078
6079     return r;
6080 }
6081
6082 static UINT ITERATE_InstallODBCDataSource( MSIRECORD *rec, LPVOID param )
6083 {
6084     MSIPACKAGE *package = param;
6085     LPWSTR attrs;
6086     LPCWSTR desc, driver;
6087     WORD request = ODBC_ADD_SYS_DSN;
6088     INT registration;
6089     DWORD len;
6090     UINT r = ERROR_SUCCESS;
6091     MSIRECORD *uirow;
6092
6093     static const WCHAR attrs_fmt[] = {
6094         'D','S','N','=','%','s',0 };
6095
6096     desc = MSI_RecordGetString(rec, 3);
6097     driver = MSI_RecordGetString(rec, 4);
6098     registration = MSI_RecordGetInteger(rec, 5);
6099
6100     if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_ADD_SYS_DSN;
6101     else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_ADD_DSN;
6102
6103     len = lstrlenW(attrs_fmt) + lstrlenW(desc) + 2; /* \0\0 */
6104     attrs = msi_alloc(len * sizeof(WCHAR));
6105     if (!attrs)
6106         return ERROR_OUTOFMEMORY;
6107
6108     len = sprintfW(attrs, attrs_fmt, desc);
6109     attrs[len + 1] = 0;
6110
6111     if (!SQLConfigDataSourceW(NULL, request, driver, attrs))
6112     {
6113         ERR("Failed to install SQL data source!\n");
6114         r = ERROR_FUNCTION_FAILED;
6115     }
6116
6117     uirow = MSI_CreateRecord( 5 );
6118     MSI_RecordSetStringW( uirow, 1, desc );
6119     MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6120     MSI_RecordSetInteger( uirow, 3, request );
6121     ui_actiondata( package, szInstallODBC, uirow );
6122     msiobj_release( &uirow->hdr );
6123
6124     msi_free(attrs);
6125
6126     return r;
6127 }
6128
6129 static UINT ACTION_InstallODBC( MSIPACKAGE *package )
6130 {
6131     UINT rc;
6132     MSIQUERY *view;
6133
6134     static const WCHAR driver_query[] = {
6135         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6136         'O','D','B','C','D','r','i','v','e','r',0 };
6137
6138     static const WCHAR translator_query[] = {
6139         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6140         'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0 };
6141
6142     static const WCHAR source_query[] = {
6143         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6144         'O','D','B','C','D','a','t','a','S','o','u','r','c','e',0 };
6145
6146     rc = MSI_DatabaseOpenViewW(package->db, driver_query, &view);
6147     if (rc != ERROR_SUCCESS)
6148         return ERROR_SUCCESS;
6149
6150     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDriver, package);
6151     msiobj_release(&view->hdr);
6152
6153     rc = MSI_DatabaseOpenViewW(package->db, translator_query, &view);
6154     if (rc != ERROR_SUCCESS)
6155         return ERROR_SUCCESS;
6156
6157     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCTranslator, package);
6158     msiobj_release(&view->hdr);
6159
6160     rc = MSI_DatabaseOpenViewW(package->db, source_query, &view);
6161     if (rc != ERROR_SUCCESS)
6162         return ERROR_SUCCESS;
6163
6164     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDataSource, package);
6165     msiobj_release(&view->hdr);
6166
6167     return rc;
6168 }
6169
6170 static UINT ITERATE_RemoveODBCDriver( MSIRECORD *rec, LPVOID param )
6171 {
6172     MSIPACKAGE *package = param;
6173     MSIRECORD *uirow;
6174     DWORD usage;
6175     LPCWSTR desc;
6176
6177     desc = MSI_RecordGetString( rec, 3 );
6178     if (!SQLRemoveDriverW( desc, FALSE, &usage ))
6179     {
6180         WARN("Failed to remove ODBC driver\n");
6181     }
6182     else if (!usage)
6183     {
6184         FIXME("Usage count reached 0\n");
6185     }
6186
6187     uirow = MSI_CreateRecord( 2 );
6188     MSI_RecordSetStringW( uirow, 1, desc );
6189     MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6190     ui_actiondata( package, szRemoveODBC, uirow );
6191     msiobj_release( &uirow->hdr );
6192
6193     return ERROR_SUCCESS;
6194 }
6195
6196 static UINT ITERATE_RemoveODBCTranslator( MSIRECORD *rec, LPVOID param )
6197 {
6198     MSIPACKAGE *package = param;
6199     MSIRECORD *uirow;
6200     DWORD usage;
6201     LPCWSTR desc;
6202
6203     desc = MSI_RecordGetString( rec, 3 );
6204     if (!SQLRemoveTranslatorW( desc, &usage ))
6205     {
6206         WARN("Failed to remove ODBC translator\n");
6207     }
6208     else if (!usage)
6209     {
6210         FIXME("Usage count reached 0\n");
6211     }
6212
6213     uirow = MSI_CreateRecord( 2 );
6214     MSI_RecordSetStringW( uirow, 1, desc );
6215     MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6216     ui_actiondata( package, szRemoveODBC, uirow );
6217     msiobj_release( &uirow->hdr );
6218
6219     return ERROR_SUCCESS;
6220 }
6221
6222 static UINT ITERATE_RemoveODBCDataSource( MSIRECORD *rec, LPVOID param )
6223 {
6224     MSIPACKAGE *package = param;
6225     MSIRECORD *uirow;
6226     LPWSTR attrs;
6227     LPCWSTR desc, driver;
6228     WORD request = ODBC_REMOVE_SYS_DSN;
6229     INT registration;
6230     DWORD len;
6231
6232     static const WCHAR attrs_fmt[] = {
6233         'D','S','N','=','%','s',0 };
6234
6235     desc = MSI_RecordGetString( rec, 3 );
6236     driver = MSI_RecordGetString( rec, 4 );
6237     registration = MSI_RecordGetInteger( rec, 5 );
6238
6239     if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_REMOVE_SYS_DSN;
6240     else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_REMOVE_DSN;
6241
6242     len = strlenW( attrs_fmt ) + strlenW( desc ) + 2; /* \0\0 */
6243     attrs = msi_alloc( len * sizeof(WCHAR) );
6244     if (!attrs)
6245         return ERROR_OUTOFMEMORY;
6246
6247     FIXME("Use ODBCSourceAttribute table\n");
6248
6249     len = sprintfW( attrs, attrs_fmt, desc );
6250     attrs[len + 1] = 0;
6251
6252     if (!SQLConfigDataSourceW( NULL, request, driver, attrs ))
6253     {
6254         WARN("Failed to remove ODBC data source\n");
6255     }
6256     msi_free( attrs );
6257
6258     uirow = MSI_CreateRecord( 3 );
6259     MSI_RecordSetStringW( uirow, 1, desc );
6260     MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6261     MSI_RecordSetInteger( uirow, 3, request );
6262     ui_actiondata( package, szRemoveODBC, uirow );
6263     msiobj_release( &uirow->hdr );
6264
6265     return ERROR_SUCCESS;
6266 }
6267
6268 static UINT ACTION_RemoveODBC( MSIPACKAGE *package )
6269 {
6270     UINT rc;
6271     MSIQUERY *view;
6272
6273     static const WCHAR driver_query[] = {
6274         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6275         'O','D','B','C','D','r','i','v','e','r',0 };
6276
6277     static const WCHAR translator_query[] = {
6278         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6279         'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0 };
6280
6281     static const WCHAR source_query[] = {
6282         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6283         'O','D','B','C','D','a','t','a','S','o','u','r','c','e',0 };
6284
6285     rc = MSI_DatabaseOpenViewW( package->db, driver_query, &view );
6286     if (rc != ERROR_SUCCESS)
6287         return ERROR_SUCCESS;
6288
6289     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCDriver, package );
6290     msiobj_release( &view->hdr );
6291
6292     rc = MSI_DatabaseOpenViewW( package->db, translator_query, &view );
6293     if (rc != ERROR_SUCCESS)
6294         return ERROR_SUCCESS;
6295
6296     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCTranslator, package );
6297     msiobj_release( &view->hdr );
6298
6299     rc = MSI_DatabaseOpenViewW( package->db, source_query, &view );
6300     if (rc != ERROR_SUCCESS)
6301         return ERROR_SUCCESS;
6302
6303     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCDataSource, package );
6304     msiobj_release( &view->hdr );
6305
6306     return rc;
6307 }
6308
6309 #define ENV_ACT_SETALWAYS   0x1
6310 #define ENV_ACT_SETABSENT   0x2
6311 #define ENV_ACT_REMOVE      0x4
6312 #define ENV_ACT_REMOVEMATCH 0x8
6313
6314 #define ENV_MOD_MACHINE     0x20000000
6315 #define ENV_MOD_APPEND      0x40000000
6316 #define ENV_MOD_PREFIX      0x80000000
6317 #define ENV_MOD_MASK        0xC0000000
6318
6319 #define check_flag_combo(x, y) ((x) & ~(y)) == (y)
6320
6321 static UINT env_parse_flags( LPCWSTR *name, LPCWSTR *value, DWORD *flags )
6322 {
6323     LPCWSTR cptr = *name;
6324
6325     static const WCHAR prefix[] = {'[','~',']',0};
6326     static const int prefix_len = 3;
6327
6328     *flags = 0;
6329     while (*cptr)
6330     {
6331         if (*cptr == '=')
6332             *flags |= ENV_ACT_SETALWAYS;
6333         else if (*cptr == '+')
6334             *flags |= ENV_ACT_SETABSENT;
6335         else if (*cptr == '-')
6336             *flags |= ENV_ACT_REMOVE;
6337         else if (*cptr == '!')
6338             *flags |= ENV_ACT_REMOVEMATCH;
6339         else if (*cptr == '*')
6340             *flags |= ENV_MOD_MACHINE;
6341         else
6342             break;
6343
6344         cptr++;
6345         (*name)++;
6346     }
6347
6348     if (!*cptr)
6349     {
6350         ERR("Missing environment variable\n");
6351         return ERROR_FUNCTION_FAILED;
6352     }
6353
6354     if (*value)
6355     {
6356         LPCWSTR ptr = *value;
6357         if (!strncmpW(ptr, prefix, prefix_len))
6358         {
6359             if (ptr[prefix_len] == szSemiColon[0])
6360             {
6361                 *flags |= ENV_MOD_APPEND;
6362                 *value += lstrlenW(prefix);
6363             }
6364             else
6365             {
6366                 *value = NULL;
6367             }
6368         }
6369         else if (lstrlenW(*value) >= prefix_len)
6370         {
6371             ptr += lstrlenW(ptr) - prefix_len;
6372             if (!strcmpW( ptr, prefix ))
6373             {
6374                 if ((ptr-1) > *value && *(ptr-1) == szSemiColon[0])
6375                 {
6376                     *flags |= ENV_MOD_PREFIX;
6377                     /* the "[~]" will be removed by deformat_string */;
6378                 }
6379                 else
6380                 {
6381                     *value = NULL;
6382                 }
6383             }
6384         }
6385     }
6386
6387     if (check_flag_combo(*flags, ENV_ACT_SETALWAYS | ENV_ACT_SETABSENT) ||
6388         check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETABSENT) ||
6389         check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETALWAYS) ||
6390         check_flag_combo(*flags, ENV_ACT_SETABSENT | ENV_MOD_MASK))
6391     {
6392         ERR("Invalid flags: %08x\n", *flags);
6393         return ERROR_FUNCTION_FAILED;
6394     }
6395
6396     if (!*flags)
6397         *flags = ENV_ACT_SETALWAYS | ENV_ACT_REMOVE;
6398
6399     return ERROR_SUCCESS;
6400 }
6401
6402 static UINT open_env_key( DWORD flags, HKEY *key )
6403 {
6404     static const WCHAR user_env[] =
6405         {'E','n','v','i','r','o','n','m','e','n','t',0};
6406     static const WCHAR machine_env[] =
6407         {'S','y','s','t','e','m','\\',
6408          'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
6409          'C','o','n','t','r','o','l','\\',
6410          'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
6411          'E','n','v','i','r','o','n','m','e','n','t',0};
6412     const WCHAR *env;
6413     HKEY root;
6414     LONG res;
6415
6416     if (flags & ENV_MOD_MACHINE)
6417     {
6418         env = machine_env;
6419         root = HKEY_LOCAL_MACHINE;
6420     }
6421     else
6422     {
6423         env = user_env;
6424         root = HKEY_CURRENT_USER;
6425     }
6426
6427     res = RegOpenKeyExW( root, env, 0, KEY_ALL_ACCESS, key );
6428     if (res != ERROR_SUCCESS)
6429     {
6430         WARN("Failed to open key %s (%d)\n", debugstr_w(env), res);
6431         return ERROR_FUNCTION_FAILED;
6432     }
6433
6434     return ERROR_SUCCESS;
6435 }
6436
6437 static UINT ITERATE_WriteEnvironmentString( MSIRECORD *rec, LPVOID param )
6438 {
6439     MSIPACKAGE *package = param;
6440     LPCWSTR name, value, component;
6441     LPWSTR data = NULL, newval = NULL, deformatted = NULL, ptr;
6442     DWORD flags, type, size;
6443     UINT res;
6444     HKEY env = NULL;
6445     MSICOMPONENT *comp;
6446     MSIRECORD *uirow;
6447     int action = 0;
6448
6449     component = MSI_RecordGetString(rec, 4);
6450     comp = get_loaded_component(package, component);
6451     if (!comp)
6452         return ERROR_SUCCESS;
6453
6454     if (!comp->Enabled)
6455     {
6456         TRACE("component is disabled\n");
6457         return ERROR_SUCCESS;
6458     }
6459
6460     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
6461     {
6462         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
6463         comp->Action = comp->Installed;
6464         return ERROR_SUCCESS;
6465     }
6466     comp->Action = INSTALLSTATE_LOCAL;
6467
6468     name = MSI_RecordGetString(rec, 2);
6469     value = MSI_RecordGetString(rec, 3);
6470
6471     TRACE("name %s value %s\n", debugstr_w(name), debugstr_w(value));
6472
6473     res = env_parse_flags(&name, &value, &flags);
6474     if (res != ERROR_SUCCESS || !value)
6475        goto done;
6476
6477     if (value && !deformat_string(package, value, &deformatted))
6478     {
6479         res = ERROR_OUTOFMEMORY;
6480         goto done;
6481     }
6482
6483     value = deformatted;
6484
6485     res = open_env_key( flags, &env );
6486     if (res != ERROR_SUCCESS)
6487         goto done;
6488
6489     if (flags & ENV_MOD_MACHINE)
6490         action |= 0x20000000;
6491
6492     size = 0;
6493     type = REG_SZ;
6494     res = RegQueryValueExW(env, name, NULL, &type, NULL, &size);
6495     if ((res != ERROR_SUCCESS && res != ERROR_FILE_NOT_FOUND) ||
6496         (res == ERROR_SUCCESS && type != REG_SZ && type != REG_EXPAND_SZ))
6497         goto done;
6498
6499     if ((res == ERROR_FILE_NOT_FOUND || !(flags & ENV_MOD_MASK)))
6500     {
6501         action = 0x2;
6502
6503         /* Nothing to do. */
6504         if (!value)
6505         {
6506             res = ERROR_SUCCESS;
6507             goto done;
6508         }
6509
6510         /* If we are appending but the string was empty, strip ; */
6511         if ((flags & ENV_MOD_APPEND) && (value[0] == szSemiColon[0])) value++;
6512
6513         size = (lstrlenW(value) + 1) * sizeof(WCHAR);
6514         newval = strdupW(value);
6515         if (!newval)
6516         {
6517             res = ERROR_OUTOFMEMORY;
6518             goto done;
6519         }
6520     }
6521     else
6522     {
6523         action = 0x1;
6524
6525         /* Contrary to MSDN, +-variable to [~];path works */
6526         if (flags & ENV_ACT_SETABSENT && !(flags & ENV_MOD_MASK))
6527         {
6528             res = ERROR_SUCCESS;
6529             goto done;
6530         }
6531
6532         data = msi_alloc(size);
6533         if (!data)
6534         {
6535             RegCloseKey(env);
6536             return ERROR_OUTOFMEMORY;
6537         }
6538
6539         res = RegQueryValueExW(env, name, NULL, &type, (LPVOID)data, &size);
6540         if (res != ERROR_SUCCESS)
6541             goto done;
6542
6543         if (flags & ENV_ACT_REMOVEMATCH && (!value || !strcmpW( data, value )))
6544         {
6545             action = 0x4;
6546             res = RegDeleteValueW(env, name);
6547             if (res != ERROR_SUCCESS)
6548                 WARN("Failed to remove value %s (%d)\n", debugstr_w(name), res);
6549             goto done;
6550         }
6551
6552         size = (lstrlenW(data) + 1) * sizeof(WCHAR);
6553         if (flags & ENV_MOD_MASK)
6554         {
6555             DWORD mod_size;
6556             int multiplier = 0;
6557             if (flags & ENV_MOD_APPEND) multiplier++;
6558             if (flags & ENV_MOD_PREFIX) multiplier++;
6559             mod_size = lstrlenW(value) * multiplier;
6560             size += mod_size * sizeof(WCHAR);
6561         }
6562
6563         newval = msi_alloc(size);
6564         ptr = newval;
6565         if (!newval)
6566         {
6567             res = ERROR_OUTOFMEMORY;
6568             goto done;
6569         }
6570
6571         if (flags & ENV_MOD_PREFIX)
6572         {
6573             lstrcpyW(newval, value);
6574             ptr = newval + lstrlenW(value);
6575             action |= 0x80000000;
6576         }
6577
6578         lstrcpyW(ptr, data);
6579
6580         if (flags & ENV_MOD_APPEND)
6581         {
6582             lstrcatW(newval, value);
6583             action |= 0x40000000;
6584         }
6585     }
6586     TRACE("setting %s to %s\n", debugstr_w(name), debugstr_w(newval));
6587     res = RegSetValueExW(env, name, 0, type, (LPVOID)newval, size);
6588     if (res)
6589     {
6590         WARN("Failed to set %s to %s (%d)\n",  debugstr_w(name), debugstr_w(newval), res);
6591     }
6592
6593 done:
6594     uirow = MSI_CreateRecord( 3 );
6595     MSI_RecordSetStringW( uirow, 1, name );
6596     MSI_RecordSetStringW( uirow, 2, newval );
6597     MSI_RecordSetInteger( uirow, 3, action );
6598     ui_actiondata( package, szWriteEnvironmentStrings, uirow );
6599     msiobj_release( &uirow->hdr );
6600
6601     if (env) RegCloseKey(env);
6602     msi_free(deformatted);
6603     msi_free(data);
6604     msi_free(newval);
6605     return res;
6606 }
6607
6608 static UINT ACTION_WriteEnvironmentStrings( MSIPACKAGE *package )
6609 {
6610     UINT rc;
6611     MSIQUERY * view;
6612     static const WCHAR ExecSeqQuery[] =
6613         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6614          '`','E','n','v','i','r','o','n','m','e','n','t','`',0};
6615     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
6616     if (rc != ERROR_SUCCESS)
6617         return ERROR_SUCCESS;
6618
6619     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteEnvironmentString, package);
6620     msiobj_release(&view->hdr);
6621
6622     return rc;
6623 }
6624
6625 static UINT ITERATE_RemoveEnvironmentString( MSIRECORD *rec, LPVOID param )
6626 {
6627     MSIPACKAGE *package = param;
6628     LPCWSTR name, value, component;
6629     LPWSTR deformatted = NULL;
6630     DWORD flags;
6631     HKEY env;
6632     MSICOMPONENT *comp;
6633     MSIRECORD *uirow;
6634     int action = 0;
6635     LONG res;
6636     UINT r;
6637
6638     component = MSI_RecordGetString( rec, 4 );
6639     comp = get_loaded_component( package, component );
6640     if (!comp)
6641         return ERROR_SUCCESS;
6642
6643     if (!comp->Enabled)
6644     {
6645         TRACE("component is disabled\n");
6646         return ERROR_SUCCESS;
6647     }
6648
6649     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
6650     {
6651         TRACE("Component not scheduled for removal: %s\n", debugstr_w(component));
6652         comp->Action = comp->Installed;
6653         return ERROR_SUCCESS;
6654     }
6655     comp->Action = INSTALLSTATE_ABSENT;
6656
6657     name = MSI_RecordGetString( rec, 2 );
6658     value = MSI_RecordGetString( rec, 3 );
6659
6660     TRACE("name %s value %s\n", debugstr_w(name), debugstr_w(value));
6661
6662     r = env_parse_flags( &name, &value, &flags );
6663     if (r != ERROR_SUCCESS)
6664        return r;
6665
6666     if (!(flags & ENV_ACT_REMOVE))
6667     {
6668         TRACE("Environment variable %s not marked for removal\n", debugstr_w(name));
6669         return ERROR_SUCCESS;
6670     }
6671
6672     if (value && !deformat_string( package, value, &deformatted ))
6673         return ERROR_OUTOFMEMORY;
6674
6675     value = deformatted;
6676
6677     r = open_env_key( flags, &env );
6678     if (r != ERROR_SUCCESS)
6679     {
6680         r = ERROR_SUCCESS;
6681         goto done;
6682     }
6683
6684     if (flags & ENV_MOD_MACHINE)
6685         action |= 0x20000000;
6686
6687     TRACE("Removing %s\n", debugstr_w(name));
6688
6689     res = RegDeleteValueW( env, name );
6690     if (res != ERROR_SUCCESS)
6691     {
6692         WARN("Failed to delete value %s (%d)\n", debugstr_w(name), res);
6693         r = ERROR_SUCCESS;
6694     }
6695
6696 done:
6697     uirow = MSI_CreateRecord( 3 );
6698     MSI_RecordSetStringW( uirow, 1, name );
6699     MSI_RecordSetStringW( uirow, 2, value );
6700     MSI_RecordSetInteger( uirow, 3, action );
6701     ui_actiondata( package, szRemoveEnvironmentStrings, uirow );
6702     msiobj_release( &uirow->hdr );
6703
6704     if (env) RegCloseKey( env );
6705     msi_free( deformatted );
6706     return r;
6707 }
6708
6709 static UINT ACTION_RemoveEnvironmentStrings( MSIPACKAGE *package )
6710 {
6711     UINT rc;
6712     MSIQUERY *view;
6713     static const WCHAR query[] =
6714         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6715          '`','E','n','v','i','r','o','n','m','e','n','t','`',0};
6716
6717     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
6718     if (rc != ERROR_SUCCESS)
6719         return ERROR_SUCCESS;
6720
6721     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveEnvironmentString, package );
6722     msiobj_release( &view->hdr );
6723
6724     return rc;
6725 }
6726
6727 static UINT ACTION_ValidateProductID( MSIPACKAGE *package )
6728 {
6729     LPWSTR key, template, id;
6730     UINT r = ERROR_SUCCESS;
6731
6732     id = msi_dup_property( package->db, szProductID );
6733     if (id)
6734     {
6735         msi_free( id );
6736         return ERROR_SUCCESS;
6737     }
6738     template = msi_dup_property( package->db, szPIDTemplate );
6739     key = msi_dup_property( package->db, szPIDKEY );
6740
6741     if (key && template)
6742     {
6743         FIXME( "partial stub: template %s key %s\n", debugstr_w(template), debugstr_w(key) );
6744         r = msi_set_property( package->db, szProductID, key );
6745     }
6746     msi_free( template );
6747     msi_free( key );
6748     return r;
6749 }
6750
6751 static UINT ACTION_ScheduleReboot( MSIPACKAGE *package )
6752 {
6753     TRACE("\n");
6754     package->need_reboot = 1;
6755     return ERROR_SUCCESS;
6756 }
6757
6758 static UINT ACTION_AllocateRegistrySpace( MSIPACKAGE *package )
6759 {
6760     static const WCHAR szAvailableFreeReg[] =
6761         {'A','V','A','I','L','A','B','L','E','F','R','E','E','R','E','G',0};
6762     MSIRECORD *uirow;
6763     int space = msi_get_property_int( package->db, szAvailableFreeReg, 0 );
6764
6765     TRACE("%p %d kilobytes\n", package, space);
6766
6767     uirow = MSI_CreateRecord( 1 );
6768     MSI_RecordSetInteger( uirow, 1, space );
6769     ui_actiondata( package, szAllocateRegistrySpace, uirow );
6770     msiobj_release( &uirow->hdr );
6771
6772     return ERROR_SUCCESS;
6773 }
6774
6775 static UINT ACTION_DisableRollback( MSIPACKAGE *package )
6776 {
6777     FIXME("%p\n", package);
6778     return ERROR_SUCCESS;
6779 }
6780
6781 static UINT ACTION_InstallAdminPackage( MSIPACKAGE *package )
6782 {
6783     FIXME("%p\n", package);
6784     return ERROR_SUCCESS;
6785 }
6786
6787 static UINT ACTION_SetODBCFolders( MSIPACKAGE *package )
6788 {
6789     UINT r, count;
6790     MSIQUERY *view;
6791
6792     static const WCHAR driver_query[] = {
6793         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6794         'O','D','B','C','D','r','i','v','e','r',0 };
6795
6796     static const WCHAR translator_query[] = {
6797         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
6798         'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0 };
6799
6800     r = MSI_DatabaseOpenViewW( package->db, driver_query, &view );
6801     if (r == ERROR_SUCCESS)
6802     {
6803         count = 0;
6804         r = MSI_IterateRecords( view, &count, NULL, package );
6805         msiobj_release( &view->hdr );
6806         if (count) FIXME("ignored %u rows in ODBCDriver table\n", count);
6807     }
6808
6809     r = MSI_DatabaseOpenViewW( package->db, translator_query, &view );
6810     if (r == ERROR_SUCCESS)
6811     {
6812         count = 0;
6813         r = MSI_IterateRecords( view, &count, NULL, package );
6814         msiobj_release( &view->hdr );
6815         if (count) FIXME("ignored %u rows in ODBCTranslator table\n", count);
6816     }
6817
6818     return ERROR_SUCCESS;
6819 }
6820
6821 static UINT msi_unimplemented_action_stub( MSIPACKAGE *package,
6822                                            LPCSTR action, LPCWSTR table )
6823 {
6824     static const WCHAR query[] = {
6825         'S','E','L','E','C','T',' ','*',' ',
6826         'F','R','O','M',' ','`','%','s','`',0 };
6827     MSIQUERY *view = NULL;
6828     DWORD count = 0;
6829     UINT r;
6830
6831     r = MSI_OpenQuery( package->db, &view, query, table );
6832     if (r == ERROR_SUCCESS)
6833     {
6834         r = MSI_IterateRecords(view, &count, NULL, package);
6835         msiobj_release(&view->hdr);
6836     }
6837
6838     if (count)
6839         FIXME("%s -> %u ignored %s table values\n",
6840               action, count, debugstr_w(table));
6841
6842     return ERROR_SUCCESS;
6843 }
6844
6845 static UINT ACTION_PatchFiles( MSIPACKAGE *package )
6846 {
6847     static const WCHAR table[] = { 'P','a','t','c','h',0 };
6848     return msi_unimplemented_action_stub( package, "PatchFiles", table );
6849 }
6850
6851 static UINT ACTION_BindImage( MSIPACKAGE *package )
6852 {
6853     static const WCHAR table[] = { 'B','i','n','d','I','m','a','g','e',0 };
6854     return msi_unimplemented_action_stub( package, "BindImage", table );
6855 }
6856
6857 static UINT ACTION_IsolateComponents( MSIPACKAGE *package )
6858 {
6859     static const WCHAR table[] = {
6860         'I','s','o','l','a','t','e','d','C','o','m','p','o','n','e','n','t',0 };
6861     return msi_unimplemented_action_stub( package, "IsolateComponents", table );
6862 }
6863
6864 static UINT ACTION_MigrateFeatureStates( MSIPACKAGE *package )
6865 {
6866     static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
6867     return msi_unimplemented_action_stub( package, "MigrateFeatureStates", table );
6868 }
6869
6870 static UINT ACTION_MsiUnpublishAssemblies( MSIPACKAGE *package )
6871 {
6872     static const WCHAR table[] = {
6873         'M','s','i','A','s','s','e','m','b','l','y',0 };
6874     return msi_unimplemented_action_stub( package, "MsiUnpublishAssemblies", table );
6875 }
6876
6877 static UINT ACTION_RMCCPSearch( MSIPACKAGE *package )
6878 {
6879     static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
6880     return msi_unimplemented_action_stub( package, "RMCCPSearch", table );
6881 }
6882
6883 static UINT ACTION_RegisterComPlus( MSIPACKAGE *package )
6884 {
6885     static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
6886     return msi_unimplemented_action_stub( package, "RegisterComPlus", table );
6887 }
6888
6889 static UINT ACTION_UnregisterComPlus( MSIPACKAGE *package )
6890 {
6891     static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
6892     return msi_unimplemented_action_stub( package, "UnregisterComPlus", table );
6893 }
6894
6895 static UINT ACTION_InstallSFPCatalogFile( MSIPACKAGE *package )
6896 {
6897     static const WCHAR table[] = { 'S','F','P','C','a','t','a','l','o','g',0 };
6898     return msi_unimplemented_action_stub( package, "InstallSFPCatalogFile", table );
6899 }
6900
6901 static UINT ACTION_RemoveExistingProducts( MSIPACKAGE *package )
6902 {
6903     static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
6904     return msi_unimplemented_action_stub( package, "RemoveExistingProducts", table );
6905 }
6906
6907 typedef UINT (*STANDARDACTIONHANDLER)(MSIPACKAGE*);
6908
6909 static const struct
6910 {
6911     const WCHAR *action;
6912     UINT (*handler)(MSIPACKAGE *);
6913 }
6914 StandardActions[] =
6915 {
6916     { szAllocateRegistrySpace, ACTION_AllocateRegistrySpace },
6917     { szAppSearch, ACTION_AppSearch },
6918     { szBindImage, ACTION_BindImage },
6919     { szCCPSearch, ACTION_CCPSearch },
6920     { szCostFinalize, ACTION_CostFinalize },
6921     { szCostInitialize, ACTION_CostInitialize },
6922     { szCreateFolders, ACTION_CreateFolders },
6923     { szCreateShortcuts, ACTION_CreateShortcuts },
6924     { szDeleteServices, ACTION_DeleteServices },
6925     { szDisableRollback, ACTION_DisableRollback },
6926     { szDuplicateFiles, ACTION_DuplicateFiles },
6927     { szExecuteAction, ACTION_ExecuteAction },
6928     { szFileCost, ACTION_FileCost },
6929     { szFindRelatedProducts, ACTION_FindRelatedProducts },
6930     { szForceReboot, ACTION_ForceReboot },
6931     { szInstallAdminPackage, ACTION_InstallAdminPackage },
6932     { szInstallExecute, ACTION_InstallExecute },
6933     { szInstallExecuteAgain, ACTION_InstallExecute },
6934     { szInstallFiles, ACTION_InstallFiles},
6935     { szInstallFinalize, ACTION_InstallFinalize },
6936     { szInstallInitialize, ACTION_InstallInitialize },
6937     { szInstallSFPCatalogFile, ACTION_InstallSFPCatalogFile },
6938     { szInstallValidate, ACTION_InstallValidate },
6939     { szIsolateComponents, ACTION_IsolateComponents },
6940     { szLaunchConditions, ACTION_LaunchConditions },
6941     { szMigrateFeatureStates, ACTION_MigrateFeatureStates },
6942     { szMoveFiles, ACTION_MoveFiles },
6943     { szMsiPublishAssemblies, ACTION_MsiPublishAssemblies },
6944     { szMsiUnpublishAssemblies, ACTION_MsiUnpublishAssemblies },
6945     { szInstallODBC, ACTION_InstallODBC },
6946     { szInstallServices, ACTION_InstallServices },
6947     { szPatchFiles, ACTION_PatchFiles },
6948     { szProcessComponents, ACTION_ProcessComponents },
6949     { szPublishComponents, ACTION_PublishComponents },
6950     { szPublishFeatures, ACTION_PublishFeatures },
6951     { szPublishProduct, ACTION_PublishProduct },
6952     { szRegisterClassInfo, ACTION_RegisterClassInfo },
6953     { szRegisterComPlus, ACTION_RegisterComPlus},
6954     { szRegisterExtensionInfo, ACTION_RegisterExtensionInfo },
6955     { szRegisterFonts, ACTION_RegisterFonts },
6956     { szRegisterMIMEInfo, ACTION_RegisterMIMEInfo },
6957     { szRegisterProduct, ACTION_RegisterProduct },
6958     { szRegisterProgIdInfo, ACTION_RegisterProgIdInfo },
6959     { szRegisterTypeLibraries, ACTION_RegisterTypeLibraries },
6960     { szRegisterUser, ACTION_RegisterUser },
6961     { szRemoveDuplicateFiles, ACTION_RemoveDuplicateFiles },
6962     { szRemoveEnvironmentStrings, ACTION_RemoveEnvironmentStrings },
6963     { szRemoveExistingProducts, ACTION_RemoveExistingProducts },
6964     { szRemoveFiles, ACTION_RemoveFiles },
6965     { szRemoveFolders, ACTION_RemoveFolders },
6966     { szRemoveIniValues, ACTION_RemoveIniValues },
6967     { szRemoveODBC, ACTION_RemoveODBC },
6968     { szRemoveRegistryValues, ACTION_RemoveRegistryValues },
6969     { szRemoveShortcuts, ACTION_RemoveShortcuts },
6970     { szResolveSource, ACTION_ResolveSource },
6971     { szRMCCPSearch, ACTION_RMCCPSearch },
6972     { szScheduleReboot, ACTION_ScheduleReboot },
6973     { szSelfRegModules, ACTION_SelfRegModules },
6974     { szSelfUnregModules, ACTION_SelfUnregModules },
6975     { szSetODBCFolders, ACTION_SetODBCFolders },
6976     { szStartServices, ACTION_StartServices },
6977     { szStopServices, ACTION_StopServices },
6978     { szUnpublishComponents, ACTION_UnpublishComponents },
6979     { szUnpublishFeatures, ACTION_UnpublishFeatures },
6980     { szUnregisterClassInfo, ACTION_UnregisterClassInfo },
6981     { szUnregisterComPlus, ACTION_UnregisterComPlus },
6982     { szUnregisterExtensionInfo, ACTION_UnregisterExtensionInfo },
6983     { szUnregisterFonts, ACTION_UnregisterFonts },
6984     { szUnregisterMIMEInfo, ACTION_UnregisterMIMEInfo },
6985     { szUnregisterProgIdInfo, ACTION_UnregisterProgIdInfo },
6986     { szUnregisterTypeLibraries, ACTION_UnregisterTypeLibraries },
6987     { szValidateProductID, ACTION_ValidateProductID },
6988     { szWriteEnvironmentStrings, ACTION_WriteEnvironmentStrings },
6989     { szWriteIniValues, ACTION_WriteIniValues },
6990     { szWriteRegistryValues, ACTION_WriteRegistryValues },
6991     { NULL, NULL },
6992 };
6993
6994 static BOOL ACTION_HandleStandardAction( MSIPACKAGE *package, LPCWSTR action, UINT *rc )
6995 {
6996     BOOL ret = FALSE;
6997     UINT i;
6998
6999     i = 0;
7000     while (StandardActions[i].action != NULL)
7001     {
7002         if (!strcmpW( StandardActions[i].action, action ))
7003         {
7004             ui_actionstart( package, action );
7005             if (StandardActions[i].handler)
7006             {
7007                 ui_actioninfo( package, action, TRUE, 0 );
7008                 *rc = StandardActions[i].handler( package );
7009                 ui_actioninfo( package, action, FALSE, *rc );
7010             }
7011             else
7012             {
7013                 FIXME("unhandled standard action %s\n", debugstr_w(action));
7014                 *rc = ERROR_SUCCESS;
7015             }
7016             ret = TRUE;
7017             break;
7018         }
7019         i++;
7020     }
7021     return ret;
7022 }
7023
7024 UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action, UINT script)
7025 {
7026     UINT rc = ERROR_SUCCESS;
7027     BOOL handled;
7028
7029     TRACE("Performing action (%s)\n", debugstr_w(action));
7030
7031     handled = ACTION_HandleStandardAction(package, action, &rc);
7032
7033     if (!handled)
7034         handled = ACTION_HandleCustomAction(package, action, &rc, script, TRUE);
7035
7036     if (!handled)
7037     {
7038         WARN("unhandled msi action %s\n", debugstr_w(action));
7039         rc = ERROR_FUNCTION_NOT_CALLED;
7040     }
7041
7042     return rc;
7043 }
7044
7045 UINT ACTION_PerformUIAction(MSIPACKAGE *package, const WCHAR *action, UINT script)
7046 {
7047     UINT rc = ERROR_SUCCESS;
7048     BOOL handled = FALSE;
7049
7050     TRACE("Performing action (%s)\n", debugstr_w(action));
7051
7052     handled = ACTION_HandleStandardAction(package, action, &rc);
7053
7054     if (!handled)
7055         handled = ACTION_HandleCustomAction(package, action, &rc, script, FALSE);
7056
7057     if( !handled && ACTION_DialogBox(package, action) == ERROR_SUCCESS )
7058         handled = TRUE;
7059
7060     if (!handled)
7061     {
7062         WARN("unhandled msi action %s\n", debugstr_w(action));
7063         rc = ERROR_FUNCTION_NOT_CALLED;
7064     }
7065
7066     return rc;
7067 }
7068
7069 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq)
7070 {
7071     UINT rc = ERROR_SUCCESS;
7072     MSIRECORD *row;
7073
7074     static const WCHAR ExecSeqQuery[] =
7075         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7076          '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
7077          'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
7078          '`','S','e','q','u','e','n','c','e','`',' ', '=',' ','%','i',0};
7079     static const WCHAR UISeqQuery[] =
7080         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
7081      '`','I','n','s','t','a','l','l','U','I','S','e','q','u','e','n','c','e',
7082      '`', ' ', 'W','H','E','R','E',' ','`','S','e','q','u','e','n','c','e','`',
7083          ' ', '=',' ','%','i',0};
7084
7085     if (needs_ui_sequence(package))
7086         row = MSI_QueryGetRecord(package->db, UISeqQuery, seq);
7087     else
7088         row = MSI_QueryGetRecord(package->db, ExecSeqQuery, seq);
7089
7090     if (row)
7091     {
7092         LPCWSTR action, cond;
7093
7094         TRACE("Running the actions\n");
7095
7096         /* check conditions */
7097         cond = MSI_RecordGetString(row, 2);
7098
7099         /* this is a hack to skip errors in the condition code */
7100         if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
7101         {
7102             msiobj_release(&row->hdr);
7103             return ERROR_SUCCESS;
7104         }
7105
7106         action = MSI_RecordGetString(row, 1);
7107         if (!action)
7108         {
7109             ERR("failed to fetch action\n");
7110             msiobj_release(&row->hdr);
7111             return ERROR_FUNCTION_FAILED;
7112         }
7113
7114         if (needs_ui_sequence(package))
7115             rc = ACTION_PerformUIAction(package, action, -1);
7116         else
7117             rc = ACTION_PerformAction(package, action, -1);
7118
7119         msiobj_release(&row->hdr);
7120     }
7121
7122     return rc;
7123 }
7124
7125 /****************************************************
7126  * TOP level entry points
7127  *****************************************************/
7128
7129 UINT MSI_InstallPackage( MSIPACKAGE *package, LPCWSTR szPackagePath,
7130                          LPCWSTR szCommandLine )
7131 {
7132     UINT rc;
7133     BOOL ui_exists;
7134
7135     static const WCHAR szAction[] = {'A','C','T','I','O','N',0};
7136     static const WCHAR szInstall[] = {'I','N','S','T','A','L','L',0};
7137
7138     msi_set_property( package->db, szAction, szInstall );
7139
7140     package->script->InWhatSequence = SEQUENCE_INSTALL;
7141
7142     if (szPackagePath)
7143     {
7144         LPWSTR p, dir;
7145         LPCWSTR file;
7146
7147         dir = strdupW(szPackagePath);
7148         p = strrchrW(dir, '\\');
7149         if (p)
7150         {
7151             *(++p) = 0;
7152             file = szPackagePath + (p - dir);
7153         }
7154         else
7155         {
7156             msi_free(dir);
7157             dir = msi_alloc(MAX_PATH * sizeof(WCHAR));
7158             GetCurrentDirectoryW(MAX_PATH, dir);
7159             lstrcatW(dir, szBackSlash);
7160             file = szPackagePath;
7161         }
7162
7163         msi_free( package->PackagePath );
7164         package->PackagePath = msi_alloc((lstrlenW(dir) + lstrlenW(file) + 1) * sizeof(WCHAR));
7165         if (!package->PackagePath)
7166         {
7167             msi_free(dir);
7168             return ERROR_OUTOFMEMORY;
7169         }
7170
7171         lstrcpyW(package->PackagePath, dir);
7172         lstrcatW(package->PackagePath, file);
7173         msi_free(dir);
7174
7175         msi_set_sourcedir_props(package, FALSE);
7176     }
7177
7178     msi_parse_command_line( package, szCommandLine, FALSE );
7179
7180     msi_apply_transforms( package );
7181     msi_apply_patches( package );
7182
7183     if (!szCommandLine && msi_get_property_int( package->db, szInstalled, 0 ))
7184     {
7185         TRACE("setting reinstall property\n");
7186         msi_set_property( package->db, szReinstall, szAll );
7187     }
7188
7189     /* properties may have been added by a transform */
7190     msi_clone_properties( package );
7191
7192     msi_parse_command_line( package, szCommandLine, FALSE );
7193     msi_adjust_privilege_properties( package );
7194     msi_set_context( package );
7195
7196     if (needs_ui_sequence( package))
7197     {
7198         package->script->InWhatSequence |= SEQUENCE_UI;
7199         rc = ACTION_ProcessUISequence(package);
7200         ui_exists = ui_sequence_exists(package);
7201         if (rc == ERROR_SUCCESS || !ui_exists)
7202         {
7203             package->script->InWhatSequence |= SEQUENCE_EXEC;
7204             rc = ACTION_ProcessExecSequence(package, ui_exists);
7205         }
7206     }
7207     else
7208         rc = ACTION_ProcessExecSequence(package, FALSE);
7209
7210     package->script->CurrentlyScripting = FALSE;
7211
7212     /* process the ending type action */
7213     if (rc == ERROR_SUCCESS)
7214         ACTION_PerformActionSequence(package, -1);
7215     else if (rc == ERROR_INSTALL_USEREXIT)
7216         ACTION_PerformActionSequence(package, -2);
7217     else if (rc == ERROR_INSTALL_SUSPEND)
7218         ACTION_PerformActionSequence(package, -4);
7219     else  /* failed */
7220         ACTION_PerformActionSequence(package, -3);
7221
7222     /* finish up running custom actions */
7223     ACTION_FinishCustomActions(package);
7224
7225     if (rc == ERROR_SUCCESS && package->need_reboot)
7226         return ERROR_SUCCESS_REBOOT_REQUIRED;
7227
7228     return rc;
7229 }