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