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