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