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