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