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