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 /*
  22  * Pages I need
  23  *
  24 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/msi/setup/installexecutesequence_table.asp
  25
  26 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/msi/setup/standard_actions_reference.asp
  27  */
  28
  29 #include <stdarg.h>
  30
  31 #define COBJMACROS
  32
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winerror.h"
  36 #include "winreg.h"
  37 #include "winsvc.h"
  38 #include "odbcinst.h"
  39 #include "wine/debug.h"
  40 #include "msidefs.h"
  41 #include "msipriv.h"
  42 #include "winuser.h"
  43 #include "shlobj.h"
  44 #include "wine/unicode.h"
  45 #include "winver.h"
  46
  47 #define REG_PROGRESS_VALUE 13200
  48 #define COMPONENT_PROGRESS_VALUE 24000
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  51
  52 /*
  53  * Prototypes
  54  */
  55 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran);
  56 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package);
  57 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq, BOOL UI);
  58
  59 /*
  60  * consts and values used
  61  */
  62 static const WCHAR c_colon[] = {'C',':','\\',0};
  63
  64 static const WCHAR szCreateFolders[] =
  65     {'C','r','e','a','t','e','F','o','l','d','e','r','s',0};
  66 static const WCHAR szCostFinalize[] =
  67     {'C','o','s','t','F','i','n','a','l','i','z','e',0};
  68 const WCHAR szInstallFiles[] =
  69     {'I','n','s','t','a','l','l','F','i','l','e','s',0};
  70 const WCHAR szDuplicateFiles[] =
  71     {'D','u','p','l','i','c','a','t','e','F','i','l','e','s',0};
  72 static const WCHAR szWriteRegistryValues[] =
  73     {'W','r','i','t','e','R','e','g','i','s','t','r','y',
  74             'V','a','l','u','e','s',0};
  75 static const WCHAR szCostInitialize[] =
  76     {'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0};
  77 static const WCHAR szFileCost[] =
  78     {'F','i','l','e','C','o','s','t',0};
  79 static const WCHAR szInstallInitialize[] =
  80     {'I','n','s','t','a','l','l','I','n','i','t','i','a','l','i','z','e',0};
  81 static const WCHAR szInstallValidate[] =
  82     {'I','n','s','t','a','l','l','V','a','l','i','d','a','t','e',0};
  83 static const WCHAR szLaunchConditions[] =
  84     {'L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','s',0};
  85 static const WCHAR szProcessComponents[] =
  86     {'P','r','o','c','e','s','s','C','o','m','p','o','n','e','n','t','s',0};
  87 static const WCHAR szRegisterTypeLibraries[] =
  88     {'R','e','g','i','s','t','e','r','T','y','p','e',
  89             'L','i','b','r','a','r','i','e','s',0};
  90 const WCHAR szRegisterClassInfo[] =
  91     {'R','e','g','i','s','t','e','r','C','l','a','s','s','I','n','f','o',0};
  92 const WCHAR szRegisterProgIdInfo[] =
  93     {'R','e','g','i','s','t','e','r','P','r','o','g','I','d','I','n','f','o',0};
  94 static const WCHAR szCreateShortcuts[] =
  95     {'C','r','e','a','t','e','S','h','o','r','t','c','u','t','s',0};
  96 static const WCHAR szPublishProduct[] =
  97     {'P','u','b','l','i','s','h','P','r','o','d','u','c','t',0};
  98 static const WCHAR szWriteIniValues[] =
  99     {'W','r','i','t','e','I','n','i','V','a','l','u','e','s',0};
 100 static const WCHAR szSelfRegModules[] =
 101     {'S','e','l','f','R','e','g','M','o','d','u','l','e','s',0};
 102 static const WCHAR szPublishFeatures[] =
 103     {'P','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
 104 static const WCHAR szRegisterProduct[] =
 105     {'R','e','g','i','s','t','e','r','P','r','o','d','u','c','t',0};
 106 static const WCHAR szInstallExecute[] =
 107     {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',0};
 108 static const WCHAR szInstallExecuteAgain[] =
 109     {'I','n','s','t','a','l','l','E','x','e','c','u','t','e',
 110             'A','g','a','i','n',0};
 111 static const WCHAR szInstallFinalize[] =
 112     {'I','n','s','t','a','l','l','F','i','n','a','l','i','z','e',0};
 113 static const WCHAR szForceReboot[] =
 114     {'F','o','r','c','e','R','e','b','o','o','t',0};
 115 static const WCHAR szResolveSource[] =
 116     {'R','e','s','o','l','v','e','S','o','u','r','c','e',0};
 117 static const WCHAR szAppSearch[] =
 118     {'A','p','p','S','e','a','r','c','h',0};
 119 static const WCHAR szAllocateRegistrySpace[] =
 120     {'A','l','l','o','c','a','t','e','R','e','g','i','s','t','r','y',
 121             'S','p','a','c','e',0};
 122 static const WCHAR szBindImage[] =
 123     {'B','i','n','d','I','m','a','g','e',0};
 124 static const WCHAR szCCPSearch[] =
 125     {'C','C','P','S','e','a','r','c','h',0};
 126 static const WCHAR szDeleteServices[] =
 127     {'D','e','l','e','t','e','S','e','r','v','i','c','e','s',0};
 128 static const WCHAR szDisableRollback[] =
 129     {'D','i','s','a','b','l','e','R','o','l','l','b','a','c','k',0};
 130 static const WCHAR szExecuteAction[] =
 131     {'E','x','e','c','u','t','e','A','c','t','i','o','n',0};
 132 const WCHAR szFindRelatedProducts[] =
 133     {'F','i','n','d','R','e','l','a','t','e','d',
 134             'P','r','o','d','u','c','t','s',0};
 135 static const WCHAR szInstallAdminPackage[] =
 136     {'I','n','s','t','a','l','l','A','d','m','i','n',
 137             'P','a','c','k','a','g','e',0};
 138 static const WCHAR szInstallSFPCatalogFile[] =
 139     {'I','n','s','t','a','l','l','S','F','P','C','a','t','a','l','o','g',
 140             'F','i','l','e',0};
 141 static const WCHAR szIsolateComponents[] =
 142     {'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t','s',0};
 143 const WCHAR szMigrateFeatureStates[] =
 144     {'M','i','g','r','a','t','e','F','e','a','t','u','r','e',
 145             'S','t','a','t','e','s',0};
 146 const WCHAR szMoveFiles[] =
 147     {'M','o','v','e','F','i','l','e','s',0};
 148 static const WCHAR szMsiPublishAssemblies[] =
 149     {'M','s','i','P','u','b','l','i','s','h',
 150             'A','s','s','e','m','b','l','i','e','s',0};
 151 static const WCHAR szMsiUnpublishAssemblies[] =
 152     {'M','s','i','U','n','p','u','b','l','i','s','h',
 153             'A','s','s','e','m','b','l','i','e','s',0};
 154 static const WCHAR szInstallODBC[] =
 155     {'I','n','s','t','a','l','l','O','D','B','C',0};
 156 static const WCHAR szInstallServices[] =
 157     {'I','n','s','t','a','l','l','S','e','r','v','i','c','e','s',0};
 158 const WCHAR szPatchFiles[] =
 159     {'P','a','t','c','h','F','i','l','e','s',0};
 160 static const WCHAR szPublishComponents[] =
 161     {'P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t','s',0};
 162 static const WCHAR szRegisterComPlus[] =
 163     {'R','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
 164 const WCHAR szRegisterExtensionInfo[] =
 165     {'R','e','g','i','s','t','e','r','E','x','t','e','n','s','i','o','n',
 166             'I','n','f','o',0};
 167 static const WCHAR szRegisterFonts[] =
 168     {'R','e','g','i','s','t','e','r','F','o','n','t','s',0};
 169 const WCHAR szRegisterMIMEInfo[] =
 170     {'R','e','g','i','s','t','e','r','M','I','M','E','I','n','f','o',0};
 171 static const WCHAR szRegisterUser[] =
 172     {'R','e','g','i','s','t','e','r','U','s','e','r',0};
 173 const WCHAR szRemoveDuplicateFiles[] =
 174     {'R','e','m','o','v','e','D','u','p','l','i','c','a','t','e',
 175             'F','i','l','e','s',0};
 176 static const WCHAR szRemoveEnvironmentStrings[] =
 177     {'R','e','m','o','v','e','E','n','v','i','r','o','n','m','e','n','t',
 178             'S','t','r','i','n','g','s',0};
 179 const WCHAR szRemoveExistingProducts[] =
 180     {'R','e','m','o','v','e','E','x','i','s','t','i','n','g',
 181             'P','r','o','d','u','c','t','s',0};
 182 const WCHAR szRemoveFiles[] =
 183     {'R','e','m','o','v','e','F','i','l','e','s',0};
 184 static const WCHAR szRemoveFolders[] =
 185     {'R','e','m','o','v','e','F','o','l','d','e','r','s',0};
 186 static const WCHAR szRemoveIniValues[] =
 187     {'R','e','m','o','v','e','I','n','i','V','a','l','u','e','s',0};
 188 static const WCHAR szRemoveODBC[] =
 189     {'R','e','m','o','v','e','O','D','B','C',0};
 190 static const WCHAR szRemoveRegistryValues[] =
 191     {'R','e','m','o','v','e','R','e','g','i','s','t','r','y',
 192             'V','a','l','u','e','s',0};
 193 static const WCHAR szRemoveShortcuts[] =
 194     {'R','e','m','o','v','e','S','h','o','r','t','c','u','t','s',0};
 195 static const WCHAR szRMCCPSearch[] =
 196     {'R','M','C','C','P','S','e','a','r','c','h',0};
 197 static const WCHAR szScheduleReboot[] =
 198     {'S','c','h','e','d','u','l','e','R','e','b','o','o','t',0};
 199 static const WCHAR szSelfUnregModules[] =
 200     {'S','e','l','f','U','n','r','e','g','M','o','d','u','l','e','s',0};
 201 static const WCHAR szSetODBCFolders[] =
 202     {'S','e','t','O','D','B','C','F','o','l','d','e','r','s',0};
 203 static const WCHAR szStartServices[] =
 204     {'S','t','a','r','t','S','e','r','v','i','c','e','s',0};
 205 static const WCHAR szStopServices[] =
 206     {'S','t','o','p','S','e','r','v','i','c','e','s',0};
 207 static const WCHAR szUnpublishComponents[] =
 208     {'U','n','p','u','b','l','i','s','h',
 209             'C','o','m','p','o','n','e','n','t','s',0};
 210 static const WCHAR szUnpublishFeatures[] =
 211     {'U','n','p','u','b','l','i','s','h','F','e','a','t','u','r','e','s',0};
 212 const WCHAR szUnregisterClassInfo[] =
 213     {'U','n','r','e','g','i','s','t','e','r','C','l','a','s','s',
 214             'I','n','f','o',0};
 215 static const WCHAR szUnregisterComPlus[] =
 216     {'U','n','r','e','g','i','s','t','e','r','C','o','m','P','l','u','s',0};
 217 const WCHAR szUnregisterExtensionInfo[] =
 218     {'U','n','r','e','g','i','s','t','e','r',
 219             'E','x','t','e','n','s','i','o','n','I','n','f','o',0};
 220 static const WCHAR szUnregisterFonts[] =
 221     {'U','n','r','e','g','i','s','t','e','r','F','o','n','t','s',0};
 222 const WCHAR szUnregisterMIMEInfo[] =
 223     {'U','n','r','e','g','i','s','t','e','r','M','I','M','E','I','n','f','o',0};
 224 const WCHAR szUnregisterProgIdInfo[] =
 225     {'U','n','r','e','g','i','s','t','e','r','P','r','o','g','I','d',
 226             'I','n','f','o',0};
 227 static const WCHAR szUnregisterTypeLibraries[] =
 228     {'U','n','r','e','g','i','s','t','e','r','T','y','p','e',
 229             'L','i','b','r','a','r','i','e','s',0};
 230 static const WCHAR szValidateProductID[] =
 231     {'V','a','l','i','d','a','t','e','P','r','o','d','u','c','t','I','D',0};
 232 static const WCHAR szWriteEnvironmentStrings[] =
 233     {'W','r','i','t','e','E','n','v','i','r','o','n','m','e','n','t',
 234             'S','t','r','i','n','g','s',0};
 235
 236 /* action handlers */
 237 typedef UINT (*STANDARDACTIONHANDLER)(MSIPACKAGE*);
 238
 239 struct _actions {
 240     LPCWSTR action;
 241     STANDARDACTIONHANDLER handler;
 242 };
 243
 244 static const struct _actions StandardActions[];
 245
 246
 247 /********************************************************
 248  * helper functions
 249  ********************************************************/
 250
 251 static void ui_actionstart(MSIPACKAGE *package, LPCWSTR action)
 252 {
 253     static const WCHAR Query_t[] =
 254         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 255          '`','A','c','t','i','o', 'n','T','e','x','t','`',' ',
 256          'W','H','E','R','E', ' ','`','A','c','t','i','o','n','`',' ','=',
 257          ' ','\'','%','s','\'',0};
 258     MSIRECORD * row;
 259
 260     row = MSI_QueryGetRecord( package->db, Query_t, action );
 261     if (!row)
 262         return;
 263     MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, row);
 264     msiobj_release(&row->hdr);
 265 }
 266
 267 static void ui_actioninfo(MSIPACKAGE *package, LPCWSTR action, BOOL start,
 268                           UINT rc)
 269 {
 270     MSIRECORD * row;
 271     static const WCHAR template_s[]=
 272         {'A','c','t','i','o','n',' ','s','t','a','r','t',' ','%','s',':',' ',
 273          '%','s', '.',0};
 274     static const WCHAR template_e[]=
 275         {'A','c','t','i','o','n',' ','e','n','d','e','d',' ','%','s',':',' ',
 276          '%','s', '.',' ','R','e','t','u','r','n',' ','v','a','l','u','e',' ',
 277          '%','i','.',0};
 278     static const WCHAR format[] =
 279         {'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0};
 280     WCHAR message[1024];
 281     WCHAR timet[0x100];
 282
 283     GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, format, timet, 0x100);
 284     if (start)
 285         sprintfW(message,template_s,timet,action);
 286     else
 287         sprintfW(message,template_e,timet,action,rc);
 288
 289     row = MSI_CreateRecord(1);
 290     MSI_RecordSetStringW(row,1,message);
 291
 292     MSI_ProcessMessage(package, INSTALLMESSAGE_INFO, row);
 293     msiobj_release(&row->hdr);
 294 }
 295
 296 static UINT msi_parse_command_line( MSIPACKAGE *package, LPCWSTR szCommandLine )
 297 {
 298     LPCWSTR ptr,ptr2;
 299     BOOL quote;
 300     DWORD len;
 301     LPWSTR prop = NULL, val = NULL;
 302
 303     if (!szCommandLine)
 304         return ERROR_SUCCESS;
 305
 306     ptr = szCommandLine;
 307
 308     while (*ptr)
 309     {
 310         if (*ptr==' ')
 311         {
 312             ptr++;
 313             continue;
 314         }
 315
 316         TRACE("Looking at %s\n",debugstr_w(ptr));
 317
 318         ptr2 = strchrW(ptr,'=');
 319         if (!ptr2)
 320         {
 321             ERR("command line contains unknown string : %s\n", debugstr_w(ptr));
 322             break;
 323         }
 324
 325         quote = FALSE;
 326
 327         len = ptr2-ptr;
 328         prop = msi_alloc((len+1)*sizeof(WCHAR));
 329         memcpy(prop,ptr,len*sizeof(WCHAR));
 330         prop[len]=0;
 331         ptr2++;
 332
 333         len = 0;
 334         ptr = ptr2;
 335         while (*ptr && (quote || (!quote && *ptr!=' ')))
 336         {
 337             if (*ptr == '"')
 338                 quote = !quote;
 339             ptr++;
 340             len++;
 341         }
 342
 343         if (*ptr2=='"')
 344         {
 345             ptr2++;
 346             len -= 2;
 347         }
 348         val = msi_alloc((len+1)*sizeof(WCHAR));
 349         memcpy(val,ptr2,len*sizeof(WCHAR));
 350         val[len] = 0;
 351
 352         if (lstrlenW(prop) > 0)
 353         {
 354             TRACE("Found commandline property (%s) = (%s)\n",
 355                    debugstr_w(prop), debugstr_w(val));
 356             MSI_SetPropertyW(package,prop,val);
 357         }
 358         msi_free(val);
 359         msi_free(prop);
 360     }
 361
 362     return ERROR_SUCCESS;
 363 }
 364
 365
 366 static LPWSTR* msi_split_string( LPCWSTR str, WCHAR sep )
 367 {
 368     LPCWSTR pc;
 369     LPWSTR p, *ret = NULL;
 370     UINT count = 0;
 371
 372     if (!str)
 373         return ret;
 374
 375     /* count the number of substrings */
 376     for ( pc = str, count = 0; pc; count++ )
 377     {
 378         pc = strchrW( pc, sep );
 379         if (pc)
 380             pc++;
 381     }
 382
 383     /* allocate space for an array of substring pointers and the substrings */
 384     ret = msi_alloc( (count+1) * sizeof (LPWSTR) +
 385                      (lstrlenW(str)+1) * sizeof(WCHAR) );
 386     if (!ret)
 387         return ret;
 388
 389     /* copy the string and set the pointers */
 390     p = (LPWSTR) &ret[count+1];
 391     lstrcpyW( p, str );
 392     for( count = 0; (ret[count] = p); count++ )
 393     {
 394         p = strchrW( p, sep );
 395         if (p)
 396             *p++ = 0;
 397     }
 398
 399     return ret;
 400 }
 401
 402 static UINT msi_check_transform_applicable( MSIPACKAGE *package, IStorage *patch )
 403 {
 404     WCHAR szProductCode[] = { 'P','r','o','d','u','c','t','C','o','d','e',0 };
 405     LPWSTR prod_code, patch_product;
 406     UINT ret;
 407
 408     prod_code = msi_dup_property( package, szProductCode );
 409     patch_product = msi_get_suminfo_product( patch );
 410
 411     TRACE("db = %s patch = %s\n", debugstr_w(prod_code), debugstr_w(patch_product));
 412
 413     if ( strstrW( patch_product, prod_code ) )
 414         ret = ERROR_SUCCESS;
 415     else
 416         ret = ERROR_FUNCTION_FAILED;
 417
 418     msi_free( patch_product );
 419     msi_free( prod_code );
 420
 421     return ret;
 422 }
 423
 424 static UINT msi_apply_substorage_transform( MSIPACKAGE *package,
 425                                  MSIDATABASE *patch_db, LPCWSTR name )
 426 {
 427     UINT ret = ERROR_FUNCTION_FAILED;
 428     IStorage *stg = NULL;
 429     HRESULT r;
 430
 431     TRACE("%p %s\n", package, debugstr_w(name) );
 432
 433     if (*name++ != ':')
 434     {
 435         ERR("expected a colon in %s\n", debugstr_w(name));
 436         return ERROR_FUNCTION_FAILED;
 437     }
 438
 439     r = IStorage_OpenStorage( patch_db->storage, name, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg );
 440     if (SUCCEEDED(r))
 441     {
 442         ret = msi_check_transform_applicable( package, stg );
 443         if (ret == ERROR_SUCCESS)
 444             msi_table_apply_transform( package->db, stg );
 445         else
 446             TRACE("substorage transform %s wasn't applicable\n", debugstr_w(name));
 447         IStorage_Release( stg );
 448     }
 449     else
 450         ERR("failed to open substorage %s\n", debugstr_w(name));
 451
 452     return ERROR_SUCCESS;
 453 }
 454
 455 static UINT msi_check_patch_applicable( MSIPACKAGE *package, MSISUMMARYINFO *si )
 456 {
 457     static const WCHAR szProdCode[] = { 'P','r','o','d','u','c','t','C','o','d','e',0 };
 458     LPWSTR guid_list, *guids, product_code;
 459     UINT i, ret = ERROR_FUNCTION_FAILED;
 460
 461     product_code = msi_dup_property( package, szProdCode );
 462     if (!product_code)
 463     {
 464         /* FIXME: the property ProductCode should be written into the DB somewhere */
 465         ERR("no product code to check\n");
 466         return ERROR_SUCCESS;
 467     }
 468
 469     guid_list = msi_suminfo_dup_string( si, PID_TEMPLATE );
 470     guids = msi_split_string( guid_list, ';' );
 471     for ( i = 0; guids[i] && ret != ERROR_SUCCESS; i++ )
 472     {
 473         if (!lstrcmpW( guids[i], product_code ))
 474             ret = ERROR_SUCCESS;
 475     }
 476     msi_free( guids );
 477     msi_free( guid_list );
 478     msi_free( product_code );
 479
 480     return ret;
 481 }
 482
 483 static UINT msi_parse_patch_summary( MSIPACKAGE *package, MSIDATABASE *patch_db )
 484 {
 485     MSISUMMARYINFO *si;
 486     LPWSTR str, *substorage;
 487     UINT i, r = ERROR_SUCCESS;
 488
 489     si = MSI_GetSummaryInformationW( patch_db->storage, 0 );
 490     if (!si)
 491         return ERROR_FUNCTION_FAILED;
 492
 493     msi_check_patch_applicable( package, si );
 494
 495     /* enumerate the substorage */
 496     str = msi_suminfo_dup_string( si, PID_LASTAUTHOR );
 497     substorage = msi_split_string( str, ';' );
 498     for ( i = 0; substorage && substorage[i] && r == ERROR_SUCCESS; i++ )
 499         r = msi_apply_substorage_transform( package, patch_db, substorage[i] );
 500     msi_free( substorage );
 501     msi_free( str );
 502
 503     /* FIXME: parse the sources in PID_REVNUMBER and do something with them... */
 504
 505     msiobj_release( &si->hdr );
 506
 507     return r;
 508 }
 509
 510 static UINT msi_apply_patch_package( MSIPACKAGE *package, LPCWSTR file )
 511 {
 512     MSIDATABASE *patch_db = NULL;
 513     UINT r;
 514
 515     TRACE("%p %s\n", package, debugstr_w( file ) );
 516
 517     /* FIXME:
 518      *  We probably want to make sure we only open a patch collection here.
 519      *  Patch collections (.msp) and databases (.msi) have different GUIDs
 520      *  but currently MSI_OpenDatabaseW will accept both.
 521      */
 522     r = MSI_OpenDatabaseW( file, MSIDBOPEN_READONLY, &patch_db );
 523     if ( r != ERROR_SUCCESS )
 524     {
 525         ERR("failed to open patch collection %s\n", debugstr_w( file ) );
 526         return r;
 527     }
 528
 529     msi_parse_patch_summary( package, patch_db );
 530
 531     /*
 532      * There might be a CAB file in the patch package,
 533      * so append it to the list of storage to search for streams.
 534      */
 535     append_storage_to_db( package->db, patch_db->storage );
 536
 537     msiobj_release( &patch_db->hdr );
 538
 539     return ERROR_SUCCESS;
 540 }
 541
 542 /* get the PATCH property, and apply all the patches it specifies */
 543 static UINT msi_apply_patches( MSIPACKAGE *package )
 544 {
 545     static const WCHAR szPatch[] = { 'P','A','T','C','H',0 };
 546     LPWSTR patch_list, *patches;
 547     UINT i, r = ERROR_SUCCESS;
 548
 549     patch_list = msi_dup_property( package, szPatch );
 550
 551     TRACE("patches to be applied: %s\n", debugstr_w( patch_list ) );
 552
 553     patches = msi_split_string( patch_list, ';' );
 554     for( i=0; patches && patches[i] && r == ERROR_SUCCESS; i++ )
 555         r = msi_apply_patch_package( package, patches[i] );
 556
 557     msi_free( patches );
 558     msi_free( patch_list );
 559
 560     return r;
 561 }
 562
 563 static UINT msi_apply_transforms( MSIPACKAGE *package )
 564 {
 565     static const WCHAR szTransforms[] = {
 566         'T','R','A','N','S','F','O','R','M','S',0 };
 567     LPWSTR xform_list, *xforms;
 568     UINT i, r = ERROR_SUCCESS;
 569
 570     xform_list = msi_dup_property( package, szTransforms );
 571     xforms = msi_split_string( xform_list, ';' );
 572
 573     for( i=0; xforms && xforms[i] && r == ERROR_SUCCESS; i++ )
 574     {
 575         if (xforms[i][0] == ':')
 576             r = msi_apply_substorage_transform( package, package->db, &xforms[i][1] );
 577         else
 578             r = MSI_DatabaseApplyTransformW( package->db, xforms[i], 0 );
 579     }
 580
 581     msi_free( xforms );
 582     msi_free( xform_list );
 583
 584     return r;
 585 }
 586
 587 BOOL ui_sequence_exists( MSIPACKAGE *package )
 588 {
 589     MSIQUERY *view;
 590     UINT rc;
 591
 592     static const WCHAR ExecSeqQuery [] =
 593         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 594          '`','I','n','s','t','a','l','l',
 595          'U','I','S','e','q','u','e','n','c','e','`',
 596          ' ','W','H','E','R','E',' ',
 597          '`','S','e','q','u','e','n','c','e','`',' ',
 598          '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
 599          '`','S','e','q','u','e','n','c','e','`',0};
 600
 601     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 602     if (rc == ERROR_SUCCESS)
 603     {
 604         msiobj_release(&view->hdr);
 605         return TRUE;
 606     }
 607
 608     return FALSE;
 609 }
 610
 611 /****************************************************
 612  * TOP level entry points
 613  *****************************************************/
 614
 615 UINT MSI_InstallPackage( MSIPACKAGE *package, LPCWSTR szPackagePath,
 616                          LPCWSTR szCommandLine )
 617 {
 618     UINT rc;
 619     BOOL ui = FALSE, ui_exists;
 620     static const WCHAR szUILevel[] = {'U','I','L','e','v','e','l',0};
 621     static const WCHAR szAction[] = {'A','C','T','I','O','N',0};
 622     static const WCHAR szInstall[] = {'I','N','S','T','A','L','L',0};
 623
 624     MSI_SetPropertyW(package, szAction, szInstall);
 625
 626     package->script = msi_alloc_zero(sizeof(MSISCRIPT));
 627
 628     package->script->InWhatSequence = SEQUENCE_INSTALL;
 629
 630     if (szPackagePath)
 631     {
 632         LPWSTR p, check, path;
 633
 634         path = strdupW(szPackagePath);
 635         p = strrchrW(path,'\\');
 636         if (p)
 637         {
 638             p++;
 639             *p=0;
 640         }
 641         else
 642         {
 643             msi_free(path);
 644             path = msi_alloc(MAX_PATH*sizeof(WCHAR));
 645             GetCurrentDirectoryW(MAX_PATH,path);
 646             strcatW(path,cszbs);
 647         }
 648
 649         check = msi_dup_property( package, cszSourceDir );
 650         if (!check)
 651             MSI_SetPropertyW(package, cszSourceDir, path);
 652         msi_free(check);
 653
 654         check = msi_dup_property( package, cszSOURCEDIR );
 655         if (!check)
 656             MSI_SetPropertyW(package, cszSOURCEDIR, path);
 657
 658         msi_free( package->PackagePath );
 659         package->PackagePath = path;
 660
 661         msi_free(check);
 662     }
 663
 664     msi_parse_command_line( package, szCommandLine );
 665
 666     msi_apply_transforms( package );
 667     msi_apply_patches( package );
 668
 669     if ( (msi_get_property_int(package, szUILevel, 0) & INSTALLUILEVEL_MASK) >= INSTALLUILEVEL_REDUCED )
 670     {
 671         package->script->InWhatSequence |= SEQUENCE_UI;
 672         rc = ACTION_ProcessUISequence(package);
 673         ui = TRUE;
 674         ui_exists = ui_sequence_exists(package);
 675         if (rc == ERROR_SUCCESS || !ui_exists)
 676         {
 677             package->script->InWhatSequence |= SEQUENCE_EXEC;
 678             rc = ACTION_ProcessExecSequence(package,ui_exists);
 679         }
 680     }
 681     else
 682         rc = ACTION_ProcessExecSequence(package,FALSE);
 683
 684     if (rc == -1)
 685     {
 686         /* install was halted but should be considered a success */
 687         rc = ERROR_SUCCESS;
 688     }
 689
 690     package->script->CurrentlyScripting= FALSE;
 691
 692     /* process the ending type action */
 693     if (rc == ERROR_SUCCESS)
 694         ACTION_PerformActionSequence(package,-1,ui);
 695     else if (rc == ERROR_INSTALL_USEREXIT)
 696         ACTION_PerformActionSequence(package,-2,ui);
 697     else if (rc == ERROR_INSTALL_SUSPEND)
 698         ACTION_PerformActionSequence(package,-4,ui);
 699     else  /* failed */
 700         ACTION_PerformActionSequence(package,-3,ui);
 701
 702     /* finish up running custom actions */
 703     ACTION_FinishCustomActions(package);
 704
 705     return rc;
 706 }
 707
 708 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq, BOOL UI)
 709 {
 710     UINT rc = ERROR_SUCCESS;
 711     MSIRECORD * row = 0;
 712     static const WCHAR ExecSeqQuery[] =
 713         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 714          '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
 715          'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
 716          '`','S','e','q','u','e','n','c','e','`',' ', '=',' ','%','i',0};
 717
 718     static const WCHAR UISeqQuery[] =
 719         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 720      '`','I','n','s','t','a','l','l','U','I','S','e','q','u','e','n','c','e',
 721      '`', ' ', 'W','H','E','R','E',' ','`','S','e','q','u','e','n','c','e','`',
 722          ' ', '=',' ','%','i',0};
 723
 724     if (UI)
 725         row = MSI_QueryGetRecord(package->db, UISeqQuery, seq);
 726     else
 727         row = MSI_QueryGetRecord(package->db, ExecSeqQuery, seq);
 728
 729     if (row)
 730     {
 731         LPCWSTR action, cond;
 732
 733         TRACE("Running the actions\n");
 734
 735         /* check conditions */
 736         cond = MSI_RecordGetString(row,2);
 737
 738         /* this is a hack to skip errors in the condition code */
 739         if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
 740             goto end;
 741
 742         action = MSI_RecordGetString(row,1);
 743         if (!action)
 744         {
 745             ERR("failed to fetch action\n");
 746             rc = ERROR_FUNCTION_FAILED;
 747             goto end;
 748         }
 749
 750         if (UI)
 751             rc = ACTION_PerformUIAction(package,action,-1);
 752         else
 753             rc = ACTION_PerformAction(package,action,-1,FALSE);
 754 end:
 755         msiobj_release(&row->hdr);
 756     }
 757     else
 758         rc = ERROR_SUCCESS;
 759
 760     return rc;
 761 }
 762
 763 typedef struct {
 764     MSIPACKAGE* package;
 765     BOOL UI;
 766 } iterate_action_param;
 767
 768 static UINT ITERATE_Actions(MSIRECORD *row, LPVOID param)
 769 {
 770     iterate_action_param *iap= (iterate_action_param*)param;
 771     UINT rc;
 772     LPCWSTR cond, action;
 773
 774     action = MSI_RecordGetString(row,1);
 775     if (!action)
 776     {
 777         ERR("Error is retrieving action name\n");
 778         return ERROR_FUNCTION_FAILED;
 779     }
 780
 781     /* check conditions */
 782     cond = MSI_RecordGetString(row,2);
 783
 784     /* this is a hack to skip errors in the condition code */
 785     if (MSI_EvaluateConditionW(iap->package, cond) == MSICONDITION_FALSE)
 786     {
 787         TRACE("Skipping action: %s (condition is false)\n", debugstr_w(action));
 788         return ERROR_SUCCESS;
 789     }
 790
 791     if (iap->UI)
 792         rc = ACTION_PerformUIAction(iap->package,action,-1);
 793     else
 794         rc = ACTION_PerformAction(iap->package,action,-1,FALSE);
 795
 796     msi_dialog_check_messages( NULL );
 797
 798     if (iap->package->CurrentInstallState != ERROR_SUCCESS )
 799         rc = iap->package->CurrentInstallState;
 800
 801     if (rc == ERROR_FUNCTION_NOT_CALLED)
 802         rc = ERROR_SUCCESS;
 803
 804     if (rc != ERROR_SUCCESS)
 805         ERR("Execution halted, action %s returned %i\n", debugstr_w(action), rc);
 806
 807     return rc;
 808 }
 809
 810 UINT MSI_Sequence( MSIPACKAGE *package, LPCWSTR szTable, INT iSequenceMode )
 811 {
 812     MSIQUERY * view;
 813     UINT r;
 814     static const WCHAR query[] =
 815         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 816          '`','%','s','`',
 817          ' ','W','H','E','R','E',' ',
 818          '`','S','e','q','u','e','n','c','e','`',' ',
 819          '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
 820          '`','S','e','q','u','e','n','c','e','`',0};
 821     iterate_action_param iap;
 822
 823     /*
 824      * FIXME: probably should be checking UILevel in the
 825      *       ACTION_PerformUIAction/ACTION_PerformAction
 826      *       rather than saving the UI level here. Those
 827      *       two functions can be merged too.
 828      */
 829     iap.package = package;
 830     iap.UI = TRUE;
 831
 832     TRACE("%p %s %i\n", package, debugstr_w(szTable), iSequenceMode );
 833
 834     r = MSI_OpenQuery( package->db, &view, query, szTable );
 835     if (r == ERROR_SUCCESS)
 836     {
 837         r = MSI_IterateRecords( view, NULL, ITERATE_Actions, &iap );
 838         msiobj_release(&view->hdr);
 839     }
 840
 841     return r;
 842 }
 843
 844 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package, BOOL UIran)
 845 {
 846     MSIQUERY * view;
 847     UINT rc;
 848     static const WCHAR ExecSeqQuery[] =
 849         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
 850          '`','I','n','s','t','a','l','l','E','x','e','c','u','t','e',
 851          'S','e','q','u','e','n','c','e','`',' ', 'W','H','E','R','E',' ',
 852          '`','S','e','q','u','e','n','c','e','`',' ', '>',' ','%','i',' ',
 853          'O','R','D','E','R',' ', 'B','Y',' ',
 854          '`','S','e','q','u','e','n','c','e','`',0 };
 855     MSIRECORD * row = 0;
 856     static const WCHAR IVQuery[] =
 857         {'S','E','L','E','C','T',' ','`','S','e','q','u','e','n','c','e','`',
 858          ' ', 'F','R','O','M',' ','`','I','n','s','t','a','l','l',
 859          'E','x','e','c','u','t','e','S','e','q','u','e','n','c','e','`',' ',
 860          'W','H','E','R','E',' ','`','A','c','t','i','o','n','`',' ','=',
 861          ' ','\'', 'I','n','s','t','a','l','l',
 862          'V','a','l','i','d','a','t','e','\'', 0};
 863     INT seq = 0;
 864     iterate_action_param iap;
 865
 866     iap.package = package;
 867     iap.UI = FALSE;
 868
 869     if (package->script->ExecuteSequenceRun)
 870     {
 871         TRACE("Execute Sequence already Run\n");
 872         return ERROR_SUCCESS;
 873     }
 874
 875     package->script->ExecuteSequenceRun = TRUE;
 876
 877     /* get the sequence number */
 878     if (UIran)
 879     {
 880         row = MSI_QueryGetRecord(package->db, IVQuery);
 881         if( !row )
 882             return ERROR_FUNCTION_FAILED;
 883         seq = MSI_RecordGetInteger(row,1);
 884         msiobj_release(&row->hdr);
 885     }
 886
 887     rc = MSI_OpenQuery(package->db, &view, ExecSeqQuery, seq);
 888     if (rc == ERROR_SUCCESS)
 889     {
 890         TRACE("Running the actions\n");
 891
 892         rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, &iap);
 893         msiobj_release(&view->hdr);
 894     }
 895
 896     return rc;
 897 }
 898
 899 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package)
 900 {
 901     MSIQUERY * view;
 902     UINT rc;
 903     static const WCHAR ExecSeqQuery [] =
 904         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 905          '`','I','n','s','t','a','l','l',
 906          'U','I','S','e','q','u','e','n','c','e','`',
 907          ' ','W','H','E','R','E',' ',
 908          '`','S','e','q','u','e','n','c','e','`',' ',
 909          '>',' ','0',' ','O','R','D','E','R',' ','B','Y',' ',
 910          '`','S','e','q','u','e','n','c','e','`',0};
 911     iterate_action_param iap;
 912
 913     iap.package = package;
 914     iap.UI = TRUE;
 915
 916     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 917
 918     if (rc == ERROR_SUCCESS)
 919     {
 920         TRACE("Running the actions\n");
 921
 922         rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, &iap);
 923         msiobj_release(&view->hdr);
 924     }
 925
 926     return rc;
 927 }
 928
 929 /********************************************************
 930  * ACTION helper functions and functions that perform the actions
 931  *******************************************************/
 932 static BOOL ACTION_HandleStandardAction(MSIPACKAGE *package, LPCWSTR action,
 933                                         UINT* rc, BOOL force )
 934 {
 935     BOOL ret = FALSE;
 936     BOOL run = force;
 937     int i;
 938
 939     if (!run && !package->script->CurrentlyScripting)
 940         run = TRUE;
 941
 942     if (!run)
 943     {
 944         if (strcmpW(action,szInstallFinalize) == 0 ||
 945             strcmpW(action,szInstallExecute) == 0 ||
 946             strcmpW(action,szInstallExecuteAgain) == 0)
 947                 run = TRUE;
 948     }
 949
 950     i = 0;
 951     while (StandardActions[i].action != NULL)
 952     {
 953         if (strcmpW(StandardActions[i].action, action)==0)
 954         {
 955             if (!run)
 956             {
 957                 ui_actioninfo(package, action, TRUE, 0);
 958                 *rc = schedule_action(package,INSTALL_SCRIPT,action);
 959                 ui_actioninfo(package, action, FALSE, *rc);
 960             }
 961             else
 962             {
 963                 ui_actionstart(package, action);
 964                 if (StandardActions[i].handler)
 965                 {
 966                     *rc = StandardActions[i].handler(package);
 967                 }
 968                 else
 969                 {
 970                     FIXME("unhandled standard action %s\n",debugstr_w(action));
 971                     *rc = ERROR_SUCCESS;
 972                 }
 973             }
 974             ret = TRUE;
 975             break;
 976         }
 977         i++;
 978     }
 979     return ret;
 980 }
 981
 982 static BOOL ACTION_HandleCustomAction( MSIPACKAGE* package, LPCWSTR action,
 983                                        UINT* rc, UINT script, BOOL force )
 984 {
 985     BOOL ret=FALSE;
 986     UINT arc;
 987
 988     arc = ACTION_CustomAction(package, action, script, force);
 989
 990     if (arc != ERROR_CALL_NOT_IMPLEMENTED)
 991     {
 992         *rc = arc;
 993         ret = TRUE;
 994     }
 995     return ret;
 996 }
 997
 998 /*
 999  * A lot of actions are really important even if they don't do anything
1000  * explicit... Lots of properties are set at the beginning of the installation
1001  * CostFinalize does a bunch of work to translate the directories and such
1002  *
1003  * But until I get write access to the database that is hard, so I am going to
1004  * hack it to see if I can get something to run.
1005  */
1006 UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action, UINT script, BOOL force)
1007 {
1008     UINT rc = ERROR_SUCCESS;
1009     BOOL handled;
1010
1011     TRACE("Performing action (%s)\n",debugstr_w(action));
1012
1013     handled = ACTION_HandleStandardAction(package, action, &rc, force);
1014
1015     if (!handled)
1016         handled = ACTION_HandleCustomAction(package, action, &rc, script, force);
1017
1018     if (!handled)
1019     {
1020         FIXME("unhandled msi action %s\n",debugstr_w(action));
1021         rc = ERROR_FUNCTION_NOT_CALLED;
1022     }
1023
1024     return rc;
1025 }
1026
1027 UINT ACTION_PerformUIAction(MSIPACKAGE *package, const WCHAR *action, UINT script)
1028 {
1029     UINT rc = ERROR_SUCCESS;
1030     BOOL handled = FALSE;
1031
1032     TRACE("Performing action (%s)\n",debugstr_w(action));
1033
1034     handled = ACTION_HandleStandardAction(package, action, &rc,TRUE);
1035
1036     if (!handled)
1037         handled = ACTION_HandleCustomAction(package, action, &rc, script, FALSE);
1038
1039     if( !handled && ACTION_DialogBox(package,action) == ERROR_SUCCESS )
1040         handled = TRUE;
1041
1042     if (!handled)
1043     {
1044         FIXME("unhandled msi action %s\n",debugstr_w(action));
1045         rc = ERROR_FUNCTION_NOT_CALLED;
1046     }
1047
1048     return rc;
1049 }
1050
1051
1052 /*
1053  * Actual Action Handlers
1054  */
1055
1056 static UINT ITERATE_CreateFolders(MSIRECORD *row, LPVOID param)
1057 {
1058     MSIPACKAGE *package = (MSIPACKAGE*)param;
1059     LPCWSTR dir;
1060     LPWSTR full_path;
1061     MSIRECORD *uirow;
1062     MSIFOLDER *folder;
1063
1064     dir = MSI_RecordGetString(row,1);
1065     if (!dir)
1066     {
1067         ERR("Unable to get folder id\n");
1068         return ERROR_SUCCESS;
1069     }
1070
1071     full_path = resolve_folder(package,dir,FALSE,FALSE,TRUE,&folder);
1072     if (!full_path)
1073     {
1074         ERR("Unable to resolve folder id %s\n",debugstr_w(dir));
1075         return ERROR_SUCCESS;
1076     }
1077
1078     TRACE("Folder is %s\n",debugstr_w(full_path));
1079
1080     /* UI stuff */
1081     uirow = MSI_CreateRecord(1);
1082     MSI_RecordSetStringW(uirow,1,full_path);
1083     ui_actiondata(package,szCreateFolders,uirow);
1084     msiobj_release( &uirow->hdr );
1085
1086     if (folder->State == 0)
1087         create_full_pathW(full_path);
1088
1089     folder->State = 3;
1090
1091     msi_free(full_path);
1092     return ERROR_SUCCESS;
1093 }
1094
1095 /* FIXME: probably should merge this with the above function */
1096 static UINT msi_create_directory( MSIPACKAGE* package, LPCWSTR dir )
1097 {
1098     UINT rc = ERROR_SUCCESS;
1099     MSIFOLDER *folder;
1100     LPWSTR install_path;
1101
1102     install_path = resolve_folder(package, dir, FALSE, FALSE, TRUE, &folder);
1103     if (!install_path)
1104         return ERROR_FUNCTION_FAILED;
1105
1106     /* create the path */
1107     if (folder->State == 0)
1108     {
1109         create_full_pathW(install_path);
1110         folder->State = 2;
1111     }
1112     msi_free(install_path);
1113
1114     return rc;
1115 }
1116
1117 UINT msi_create_component_directories( MSIPACKAGE *package )
1118 {
1119     MSICOMPONENT *comp;
1120
1121     /* create all the folders required by the components are going to install */
1122     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1123     {
1124         if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
1125             continue;
1126         msi_create_directory( package, comp->Directory );
1127     }
1128
1129     return ERROR_SUCCESS;
1130 }
1131
1132 /*
1133  * Also we cannot enable/disable components either, so for now I am just going
1134  * to do all the directories for all the components.
1135  */
1136 static UINT ACTION_CreateFolders(MSIPACKAGE *package)
1137 {
1138     static const WCHAR ExecSeqQuery[] =
1139         {'S','E','L','E','C','T',' ',
1140          '`','D','i','r','e','c','t','o','r','y','_','`',
1141          ' ','F','R','O','M',' ',
1142          '`','C','r','e','a','t','e','F','o','l','d','e','r','`',0 };
1143     UINT rc;
1144     MSIQUERY *view;
1145
1146     /* create all the empty folders specified in the CreateFolder table */
1147     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view );
1148     if (rc != ERROR_SUCCESS)
1149         return ERROR_SUCCESS;
1150
1151     rc = MSI_IterateRecords(view, NULL, ITERATE_CreateFolders, package);
1152     msiobj_release(&view->hdr);
1153
1154     msi_create_component_directories( package );
1155
1156     return rc;
1157 }
1158
1159 static UINT load_component( MSIRECORD *row, LPVOID param )
1160 {
1161     MSIPACKAGE *package = param;
1162     MSICOMPONENT *comp;
1163
1164     comp = msi_alloc_zero( sizeof(MSICOMPONENT) );
1165     if (!comp)
1166         return ERROR_FUNCTION_FAILED;
1167
1168     list_add_tail( &package->components, &comp->entry );
1169
1170     /* fill in the data */
1171     comp->Component = msi_dup_record_field( row, 1 );
1172
1173     TRACE("Loading Component %s\n", debugstr_w(comp->Component));
1174
1175     comp->ComponentId = msi_dup_record_field( row, 2 );
1176     comp->Directory = msi_dup_record_field( row, 3 );
1177     comp->Attributes = MSI_RecordGetInteger(row,4);
1178     comp->Condition = msi_dup_record_field( row, 5 );
1179     comp->KeyPath = msi_dup_record_field( row, 6 );
1180
1181     comp->Installed = INSTALLSTATE_UNKNOWN;
1182     msi_component_set_state( comp, INSTALLSTATE_UNKNOWN );
1183
1184     return ERROR_SUCCESS;
1185 }
1186
1187 static UINT load_all_components( MSIPACKAGE *package )
1188 {
1189     static const WCHAR query[] = {
1190         'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1191          '`','C','o','m','p','o','n','e','n','t','`',0 };
1192     MSIQUERY *view;
1193     UINT r;
1194
1195     if (!list_empty(&package->components))
1196         return ERROR_SUCCESS;
1197
1198     r = MSI_DatabaseOpenViewW( package->db, query, &view );
1199     if (r != ERROR_SUCCESS)
1200         return r;
1201
1202     r = MSI_IterateRecords(view, NULL, load_component, package);
1203     msiobj_release(&view->hdr);
1204     return r;
1205 }
1206
1207 typedef struct {
1208     MSIPACKAGE *package;
1209     MSIFEATURE *feature;
1210 } _ilfs;
1211
1212 static UINT add_feature_component( MSIFEATURE *feature, MSICOMPONENT *comp )
1213 {
1214     ComponentList *cl;
1215
1216     cl = msi_alloc( sizeof (*cl) );
1217     if ( !cl )
1218         return ERROR_NOT_ENOUGH_MEMORY;
1219     cl->component = comp;
1220     list_add_tail( &feature->Components, &cl->entry );
1221
1222     return ERROR_SUCCESS;
1223 }
1224
1225 static UINT add_feature_child( MSIFEATURE *parent, MSIFEATURE *child )
1226 {
1227     FeatureList *fl;
1228
1229     fl = msi_alloc( sizeof(*fl) );
1230     if ( !fl )
1231         return ERROR_NOT_ENOUGH_MEMORY;
1232     fl->feature = child;
1233     list_add_tail( &parent->Children, &fl->entry );
1234
1235     return ERROR_SUCCESS;
1236 }
1237
1238 static UINT iterate_load_featurecomponents(MSIRECORD *row, LPVOID param)
1239 {
1240     _ilfs* ilfs= (_ilfs*)param;
1241     LPCWSTR component;
1242     MSICOMPONENT *comp;
1243
1244     component = MSI_RecordGetString(row,1);
1245
1246     /* check to see if the component is already loaded */
1247     comp = get_loaded_component( ilfs->package, component );
1248     if (!comp)
1249     {
1250         ERR("unknown component %s\n", debugstr_w(component));
1251         return ERROR_FUNCTION_FAILED;
1252     }
1253
1254     add_feature_component( ilfs->feature, comp );
1255     comp->Enabled = TRUE;
1256
1257     return ERROR_SUCCESS;
1258 }
1259
1260 static MSIFEATURE *find_feature_by_name( MSIPACKAGE *package, LPCWSTR name )
1261 {
1262     MSIFEATURE *feature;
1263
1264     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1265     {
1266         if ( !lstrcmpW( feature->Feature, name ) )
1267             return feature;
1268     }
1269
1270     return NULL;
1271 }
1272
1273 static UINT load_feature(MSIRECORD * row, LPVOID param)
1274 {
1275     MSIPACKAGE* package = (MSIPACKAGE*)param;
1276     MSIFEATURE* feature;
1277     static const WCHAR Query1[] =
1278         {'S','E','L','E','C','T',' ',
1279          '`','C','o','m','p','o','n','e','n','t','_','`',
1280          ' ','F','R','O','M',' ','`','F','e','a','t','u','r','e',
1281          'C','o','m','p','o','n','e','n','t','s','`',' ',
1282          'W','H','E','R','E',' ',
1283          '`','F','e', 'a','t','u','r','e','_','`',' ','=','\'','%','s','\'',0};
1284     MSIQUERY * view;
1285     UINT    rc;
1286     _ilfs ilfs;
1287
1288     /* fill in the data */
1289
1290     feature = msi_alloc_zero( sizeof (MSIFEATURE) );
1291     if (!feature)
1292         return ERROR_NOT_ENOUGH_MEMORY;
1293
1294     list_init( &feature->Children );
1295     list_init( &feature->Components );
1296
1297     feature->Feature = msi_dup_record_field( row, 1 );
1298
1299     TRACE("Loading feature %s\n",debugstr_w(feature->Feature));
1300
1301     feature->Feature_Parent = msi_dup_record_field( row, 2 );
1302     feature->Title = msi_dup_record_field( row, 3 );
1303     feature->Description = msi_dup_record_field( row, 4 );
1304
1305     if (!MSI_RecordIsNull(row,5))
1306         feature->Display = MSI_RecordGetInteger(row,5);
1307
1308     feature->Level= MSI_RecordGetInteger(row,6);
1309     feature->Directory = msi_dup_record_field( row, 7 );
1310     feature->Attributes = MSI_RecordGetInteger(row,8);
1311
1312     feature->Installed = INSTALLSTATE_UNKNOWN;
1313     msi_feature_set_state( feature, INSTALLSTATE_UNKNOWN );
1314
1315     list_add_tail( &package->features, &feature->entry );
1316
1317     /* load feature components */
1318
1319     rc = MSI_OpenQuery( package->db, &view, Query1, feature->Feature );
1320     if (rc != ERROR_SUCCESS)
1321         return ERROR_SUCCESS;
1322
1323     ilfs.package = package;
1324     ilfs.feature = feature;
1325
1326     MSI_IterateRecords(view, NULL, iterate_load_featurecomponents , &ilfs);
1327     msiobj_release(&view->hdr);
1328
1329     return ERROR_SUCCESS;
1330 }
1331
1332 static UINT find_feature_children(MSIRECORD * row, LPVOID param)
1333 {
1334     MSIPACKAGE* package = (MSIPACKAGE*)param;
1335     MSIFEATURE *parent, *child;
1336
1337     child = find_feature_by_name( package, MSI_RecordGetString( row, 1 ) );
1338     if (!child)
1339         return ERROR_FUNCTION_FAILED;
1340
1341     if (!child->Feature_Parent)
1342         return ERROR_SUCCESS;
1343
1344     parent = find_feature_by_name( package, child->Feature_Parent );
1345     if (!parent)
1346         return ERROR_FUNCTION_FAILED;
1347
1348     add_feature_child( parent, child );
1349     return ERROR_SUCCESS;
1350 }
1351
1352 static UINT load_all_features( MSIPACKAGE *package )
1353 {
1354     static const WCHAR query[] = {
1355         'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1356         '`','F','e','a','t','u','r','e','`',' ','O','R','D','E','R',
1357         ' ','B','Y',' ','`','D','i','s','p','l','a','y','`',0};
1358     MSIQUERY *view;
1359     UINT r;
1360
1361     if (!list_empty(&package->features))
1362         return ERROR_SUCCESS;
1363
1364     r = MSI_DatabaseOpenViewW( package->db, query, &view );
1365     if (r != ERROR_SUCCESS)
1366         return r;
1367
1368     r = MSI_IterateRecords( view, NULL, load_feature, package );
1369     if (r != ERROR_SUCCESS)
1370         return r;
1371
1372     r = MSI_IterateRecords( view, NULL, find_feature_children, package );
1373     msiobj_release( &view->hdr );
1374
1375     return r;
1376 }
1377
1378 static LPWSTR folder_split_path(LPWSTR p, WCHAR ch)
1379 {
1380     if (!p)
1381         return p;
1382     p = strchrW(p, ch);
1383     if (!p)
1384         return p;
1385     *p = 0;
1386     return p+1;
1387 }
1388
1389 static UINT load_file(MSIRECORD *row, LPVOID param)
1390 {
1391     MSIPACKAGE* package = (MSIPACKAGE*)param;
1392     LPCWSTR component;
1393     MSIFILE *file;
1394
1395     /* fill in the data */
1396
1397     file = msi_alloc_zero( sizeof (MSIFILE) );
1398     if (!file)
1399         return ERROR_NOT_ENOUGH_MEMORY;
1400
1401     file->File = msi_dup_record_field( row, 1 );
1402
1403     component = MSI_RecordGetString( row, 2 );
1404     file->Component = get_loaded_component( package, component );
1405
1406     if (!file->Component)
1407         ERR("Unfound Component %s\n",debugstr_w(component));
1408
1409     file->FileName = msi_dup_record_field( row, 3 );
1410     reduce_to_longfilename( file->FileName );
1411
1412     file->ShortName = msi_dup_record_field( row, 3 );
1413     file->LongName = strdupW( folder_split_path(file->ShortName, '|'));
1414
1415     file->FileSize = MSI_RecordGetInteger( row, 4 );
1416     file->Version = msi_dup_record_field( row, 5 );
1417     file->Language = msi_dup_record_field( row, 6 );
1418     file->Attributes = MSI_RecordGetInteger( row, 7 );
1419     file->Sequence = MSI_RecordGetInteger( row, 8 );
1420
1421     file->state = msifs_invalid;
1422
1423     /* if the compressed bits are not set in the file attributes,
1424      * then read the information from the package word count property
1425      */
1426     if (file->Attributes & msidbFileAttributesCompressed)
1427     {
1428         file->IsCompressed = TRUE;
1429     }
1430     else if (file->Attributes & msidbFileAttributesNoncompressed)
1431     {
1432         file->IsCompressed = FALSE;
1433     }
1434     else
1435     {
1436         file->IsCompressed = package->WordCount & MSIWORDCOUNT_COMPRESSED;
1437     }
1438
1439     TRACE("File Loaded (%s)\n",debugstr_w(file->File));
1440
1441     list_add_tail( &package->files, &file->entry );
1442
1443     return ERROR_SUCCESS;
1444 }
1445
1446 static UINT load_all_files(MSIPACKAGE *package)
1447 {
1448     MSIQUERY * view;
1449     UINT rc;
1450     static const WCHAR Query[] =
1451         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1452          '`','F','i','l','e','`',' ', 'O','R','D','E','R',' ','B','Y',' ',
1453          '`','S','e','q','u','e','n','c','e','`', 0};
1454
1455     if (!list_empty(&package->files))
1456         return ERROR_SUCCESS;
1457
1458     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
1459     if (rc != ERROR_SUCCESS)
1460         return ERROR_SUCCESS;
1461
1462     rc = MSI_IterateRecords(view, NULL, load_file, package);
1463     msiobj_release(&view->hdr);
1464
1465     return ERROR_SUCCESS;
1466 }
1467
1468 static UINT load_folder( MSIRECORD *row, LPVOID param )
1469 {
1470     MSIPACKAGE *package = param;
1471     static const WCHAR szDot[] = { '.',0 };
1472     static WCHAR szEmpty[] = { 0 };
1473     LPWSTR p, tgt_short, tgt_long, src_short, src_long;
1474     MSIFOLDER *folder;
1475
1476     folder = msi_alloc_zero( sizeof (MSIFOLDER) );
1477     if (!folder)
1478         return ERROR_NOT_ENOUGH_MEMORY;
1479
1480     folder->Directory = msi_dup_record_field( row, 1 );
1481
1482     TRACE("%s\n", debugstr_w(folder->Directory));
1483
1484     p = msi_dup_record_field(row, 3);
1485
1486     /* split src and target dir */
1487     tgt_short = p;
1488     src_short = folder_split_path( p, ':' );
1489
1490     /* split the long and short paths */
1491     tgt_long = folder_split_path( tgt_short, '|' );
1492     src_long = folder_split_path( src_short, '|' );
1493
1494     /* check for no-op dirs */
1495     if (!lstrcmpW(szDot, tgt_short))
1496         tgt_short = szEmpty;
1497     if (!lstrcmpW(szDot, src_short))
1498         src_short = szEmpty;
1499
1500     if (!tgt_long)
1501         tgt_long = tgt_short;
1502
1503     if (!src_short) {
1504         src_short = tgt_short;
1505         src_long = tgt_long;
1506     }
1507
1508     if (!src_long)
1509         src_long = src_short;
1510
1511     /* FIXME: use the target short path too */
1512     folder->TargetDefault = strdupW(tgt_long);
1513     folder->SourceShortPath = strdupW(src_short);
1514     folder->SourceLongPath = strdupW(src_long);
1515     msi_free(p);
1516
1517     TRACE("TargetDefault = %s\n",debugstr_w( folder->TargetDefault ));
1518     TRACE("SourceLong = %s\n", debugstr_w( folder->SourceLongPath ));
1519     TRACE("SourceShort = %s\n", debugstr_w( folder->SourceShortPath ));
1520
1521     folder->Parent = msi_dup_record_field( row, 2 );
1522
1523     folder->Property = msi_dup_property( package, folder->Directory );
1524
1525     list_add_tail( &package->folders, &folder->entry );
1526
1527     TRACE("returning %p\n", folder);
1528
1529     return ERROR_SUCCESS;
1530 }
1531
1532 static UINT load_all_folders( MSIPACKAGE *package )
1533 {
1534     static const WCHAR query[] = {
1535         'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1536          '`','D','i','r','e','c','t','o','r','y','`',0 };
1537     MSIQUERY *view;
1538     UINT r;
1539
1540     if (!list_empty(&package->folders))
1541         return ERROR_SUCCESS;
1542
1543     r = MSI_DatabaseOpenViewW( package->db, query, &view );
1544     if (r != ERROR_SUCCESS)
1545         return r;
1546
1547     r = MSI_IterateRecords(view, NULL, load_folder, package);
1548     msiobj_release(&view->hdr);
1549     return r;
1550 }
1551
1552 /*
1553  * I am not doing any of the costing functionality yet.
1554  * Mostly looking at doing the Component and Feature loading
1555  *
1556  * The native MSI does A LOT of modification to tables here. Mostly adding
1557  * a lot of temporary columns to the Feature and Component tables.
1558  *
1559  *    note: Native msi also tracks the short filename. But I am only going to
1560  *          track the long ones.  Also looking at this directory table
1561  *          it appears that the directory table does not get the parents
1562  *          resolved base on property only based on their entries in the
1563  *          directory table.
1564  */
1565 static UINT ACTION_CostInitialize(MSIPACKAGE *package)
1566 {
1567     static const WCHAR szCosting[] =
1568         {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
1569     static const WCHAR szZero[] = { '0', 0 };
1570
1571     MSI_SetPropertyW(package, szCosting, szZero);
1572     MSI_SetPropertyW(package, cszRootDrive, c_colon);
1573
1574     load_all_components( package );
1575     load_all_features( package );
1576     load_all_files( package );
1577     load_all_folders( package );
1578
1579     return ERROR_SUCCESS;
1580 }
1581
1582 static UINT execute_script(MSIPACKAGE *package, UINT script )
1583 {
1584     int i;
1585     UINT rc = ERROR_SUCCESS;
1586
1587     TRACE("Executing Script %i\n",script);
1588
1589     if (!package->script)
1590     {
1591         ERR("no script!\n");
1592         return ERROR_FUNCTION_FAILED;
1593     }
1594
1595     for (i = 0; i < package->script->ActionCount[script]; i++)
1596     {
1597         LPWSTR action;
1598         action = package->script->Actions[script][i];
1599         ui_actionstart(package, action);
1600         TRACE("Executing Action (%s)\n",debugstr_w(action));
1601         rc = ACTION_PerformAction(package, action, script, TRUE);
1602         if (rc != ERROR_SUCCESS)
1603             break;
1604     }
1605     msi_free_action_script(package, script);
1606     return rc;
1607 }
1608
1609 static UINT ACTION_FileCost(MSIPACKAGE *package)
1610 {
1611     return ERROR_SUCCESS;
1612 }
1613
1614 static void ACTION_GetComponentInstallStates(MSIPACKAGE *package)
1615 {
1616     MSICOMPONENT *comp;
1617
1618     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1619     {
1620         INSTALLSTATE res;
1621
1622         if (!comp->ComponentId)
1623             continue;
1624
1625         res = MsiGetComponentPathW( package->ProductCode,
1626                                     comp->ComponentId, NULL, NULL);
1627         if (res < 0)
1628             res = INSTALLSTATE_ABSENT;
1629         comp->Installed = res;
1630     }
1631 }
1632
1633 /* scan for and update current install states */
1634 static void ACTION_UpdateFeatureInstallStates(MSIPACKAGE *package)
1635 {
1636     MSICOMPONENT *comp;
1637     MSIFEATURE *feature;
1638
1639     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1640     {
1641         ComponentList *cl;
1642         INSTALLSTATE res = INSTALLSTATE_ABSENT;
1643
1644         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1645         {
1646             comp= cl->component;
1647
1648             if (!comp->ComponentId)
1649             {
1650                 res = INSTALLSTATE_ABSENT;
1651                 break;
1652             }
1653
1654             if (res == INSTALLSTATE_ABSENT)
1655                 res = comp->Installed;
1656             else
1657             {
1658                 if (res == comp->Installed)
1659                     continue;
1660
1661                 if (res != INSTALLSTATE_DEFAULT && res != INSTALLSTATE_LOCAL &&
1662                     res != INSTALLSTATE_SOURCE)
1663                 {
1664                     res = INSTALLSTATE_INCOMPLETE;
1665                 }
1666             }
1667         }
1668         feature->Installed = res;
1669     }
1670 }
1671
1672 static BOOL process_state_property (MSIPACKAGE* package, LPCWSTR property,
1673                                     INSTALLSTATE state)
1674 {
1675     static const WCHAR all[]={'A','L','L',0};
1676     LPWSTR override;
1677     MSIFEATURE *feature;
1678
1679     override = msi_dup_property( package, property );
1680     if (!override)
1681         return FALSE;
1682
1683     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1684     {
1685         if (strcmpiW(override,all)==0)
1686             msi_feature_set_state( feature, state );
1687         else
1688         {
1689             LPWSTR ptr = override;
1690             LPWSTR ptr2 = strchrW(override,',');
1691
1692             while (ptr)
1693             {
1694                 if ((ptr2 && strncmpW(ptr,feature->Feature, ptr2-ptr)==0)
1695                     || (!ptr2 && strcmpW(ptr,feature->Feature)==0))
1696                 {
1697                     msi_feature_set_state( feature, state );
1698                     break;
1699                 }
1700                 if (ptr2)
1701                 {
1702                     ptr=ptr2+1;
1703                     ptr2 = strchrW(ptr,',');
1704                 }
1705                 else
1706                     break;
1707             }
1708         }
1709     }
1710     msi_free(override);
1711
1712     return TRUE;
1713 }
1714
1715 UINT MSI_SetFeatureStates(MSIPACKAGE *package)
1716 {
1717     int install_level;
1718     static const WCHAR szlevel[] =
1719         {'I','N','S','T','A','L','L','L','E','V','E','L',0};
1720     static const WCHAR szAddLocal[] =
1721         {'A','D','D','L','O','C','A','L',0};
1722     static const WCHAR szRemove[] =
1723         {'R','E','M','O','V','E',0};
1724     static const WCHAR szReinstall[] =
1725         {'R','E','I','N','S','T','A','L','L',0};
1726     BOOL override = FALSE;
1727     MSICOMPONENT* component;
1728     MSIFEATURE *feature;
1729
1730
1731     /* I do not know if this is where it should happen.. but */
1732
1733     TRACE("Checking Install Level\n");
1734
1735     install_level = msi_get_property_int( package, szlevel, 1 );
1736
1737     /* ok here is the _real_ rub
1738      * all these activation/deactivation things happen in order and things
1739      * later on the list override things earlier on the list.
1740      * 1) INSTALLLEVEL processing
1741      * 2) ADDLOCAL
1742      * 3) REMOVE
1743      * 4) ADDSOURCE
1744      * 5) ADDDEFAULT
1745      * 6) REINSTALL
1746      * 7) COMPADDLOCAL
1747      * 8) COMPADDSOURCE
1748      * 9) FILEADDLOCAL
1749      * 10) FILEADDSOURCE
1750      * 11) FILEADDDEFAULT
1751      * I have confirmed that if ADDLOCAL is stated then the INSTALLLEVEL is
1752      * ignored for all the features. seems strange, especially since it is not
1753      * documented anywhere, but it is how it works.
1754      *
1755      * I am still ignoring a lot of these. But that is ok for now, ADDLOCAL and
1756      * REMOVE are the big ones, since we don't handle administrative installs
1757      * yet anyway.
1758      */
1759     override |= process_state_property(package,szAddLocal,INSTALLSTATE_LOCAL);
1760     override |= process_state_property(package,szRemove,INSTALLSTATE_ABSENT);
1761     override |= process_state_property(package,szReinstall,INSTALLSTATE_LOCAL);
1762
1763     if (!override)
1764     {
1765         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1766         {
1767             BOOL feature_state = ((feature->Level > 0) &&
1768                              (feature->Level <= install_level));
1769
1770             if ((feature_state) && (feature->Action == INSTALLSTATE_UNKNOWN))
1771             {
1772                 if (feature->Attributes & msidbFeatureAttributesFavorSource)
1773                     msi_feature_set_state( feature, INSTALLSTATE_SOURCE );
1774                 else if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1775                     msi_feature_set_state( feature, INSTALLSTATE_ADVERTISED );
1776                 else
1777                     msi_feature_set_state( feature, INSTALLSTATE_LOCAL );
1778             }
1779         }
1780
1781         /* disable child features of unselected parent features */
1782         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1783         {
1784             FeatureList *fl;
1785
1786             if (feature->Level > 0 && feature->Level <= install_level)
1787                 continue;
1788
1789             LIST_FOR_EACH_ENTRY( fl, &feature->Children, FeatureList, entry )
1790                 msi_feature_set_state( fl->feature, INSTALLSTATE_UNKNOWN );
1791         }
1792     }
1793     else
1794     {
1795         /* set the Preselected Property */
1796         static const WCHAR szPreselected[] = {'P','r','e','s','e','l','e','c','t','e','d',0};
1797         static const WCHAR szOne[] = { '1', 0 };
1798
1799         MSI_SetPropertyW(package,szPreselected,szOne);
1800     }
1801
1802     /*
1803      * now we want to enable or disable components base on feature
1804      */
1805
1806     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1807     {
1808         ComponentList *cl;
1809
1810         TRACE("Examining Feature %s (Installed %i, Action %i)\n",
1811               debugstr_w(feature->Feature), feature->Installed, feature->Action);
1812
1813         /* features with components that have compressed files are made local */
1814         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1815         {
1816             if (cl->component->Enabled &&
1817                 cl->component->ForceLocalState &&
1818                 feature->Action == INSTALLSTATE_SOURCE)
1819             {
1820                 msi_feature_set_state( feature, INSTALLSTATE_LOCAL );
1821                 break;
1822             }
1823         }
1824
1825         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1826         {
1827             component = cl->component;
1828
1829             if (!component->Enabled)
1830                 continue;
1831
1832             switch (feature->Action)
1833             {
1834             case INSTALLSTATE_ADVERTISED:
1835                 component->hasAdvertiseFeature = 1;
1836                 break;
1837             case INSTALLSTATE_SOURCE:
1838                 component->hasSourceFeature = 1;
1839                 break;
1840             case INSTALLSTATE_LOCAL:
1841                 component->hasLocalFeature = 1;
1842                 break;
1843             case INSTALLSTATE_DEFAULT:
1844                 if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1845                     component->hasAdvertiseFeature = 1;
1846                 else if (feature->Attributes & msidbFeatureAttributesFavorSource)
1847                     component->hasSourceFeature = 1;
1848                 else
1849                     component->hasLocalFeature = 1;
1850                 break;
1851             default:
1852                 break;
1853             }
1854         }
1855     }
1856
1857     LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1858     {
1859         /* if the component isn't enabled, leave it alone */
1860         if (!component->Enabled)
1861             continue;
1862
1863         /* check if it's local or source */
1864         if (!(component->Attributes & msidbComponentAttributesOptional) &&
1865              (component->hasLocalFeature || component->hasSourceFeature))
1866         {
1867             if ((component->Attributes & msidbComponentAttributesSourceOnly) &&
1868                  !component->ForceLocalState)
1869                 msi_component_set_state( component, INSTALLSTATE_SOURCE );
1870             else
1871                 msi_component_set_state( component, INSTALLSTATE_LOCAL );
1872             continue;
1873         }
1874
1875         /* if any feature is local, the component must be local too */
1876         if (component->hasLocalFeature)
1877         {
1878             msi_component_set_state( component, INSTALLSTATE_LOCAL );
1879             continue;
1880         }
1881
1882         if (component->hasSourceFeature)
1883         {
1884             msi_component_set_state( component, INSTALLSTATE_SOURCE );
1885             continue;
1886         }
1887
1888         if (component->hasAdvertiseFeature)
1889         {
1890             msi_component_set_state( component, INSTALLSTATE_ADVERTISED );
1891             continue;
1892         }
1893
1894         TRACE("nobody wants component %s\n", debugstr_w(component->Component));
1895     }
1896
1897     LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1898     {
1899         if (component->Action == INSTALLSTATE_DEFAULT)
1900         {
1901             TRACE("%s was default, setting to local\n", debugstr_w(component->Component));
1902             msi_component_set_state( component, INSTALLSTATE_LOCAL );
1903         }
1904
1905         TRACE("Result: Component %s (Installed %i, Action %i)\n",
1906             debugstr_w(component->Component), component->Installed, component->Action);
1907     }
1908
1909
1910     return ERROR_SUCCESS;
1911 }
1912
1913 static UINT ITERATE_CostFinalizeDirectories(MSIRECORD *row, LPVOID param)
1914 {
1915     MSIPACKAGE *package = (MSIPACKAGE*)param;
1916     LPCWSTR name;
1917     LPWSTR path;
1918     MSIFOLDER *f;
1919
1920     name = MSI_RecordGetString(row,1);
1921
1922     f = get_loaded_folder(package, name);
1923     if (!f) return ERROR_SUCCESS;
1924
1925     /* reset the ResolvedTarget */
1926     msi_free(f->ResolvedTarget);
1927     f->ResolvedTarget = NULL;
1928
1929     /* This helper function now does ALL the work */
1930     TRACE("Dir %s ...\n",debugstr_w(name));
1931     path = resolve_folder(package,name,FALSE,TRUE,TRUE,NULL);
1932     TRACE("resolves to %s\n",debugstr_w(path));
1933     msi_free(path);
1934
1935     return ERROR_SUCCESS;
1936 }
1937
1938 static UINT ITERATE_CostFinalizeConditions(MSIRECORD *row, LPVOID param)
1939 {
1940     MSIPACKAGE *package = (MSIPACKAGE*)param;
1941     LPCWSTR name;
1942     MSIFEATURE *feature;
1943
1944     name = MSI_RecordGetString( row, 1 );
1945
1946     feature = get_loaded_feature( package, name );
1947     if (!feature)
1948         ERR("FAILED to find loaded feature %s\n",debugstr_w(name));
1949     else
1950     {
1951         LPCWSTR Condition;
1952         Condition = MSI_RecordGetString(row,3);
1953
1954         if (MSI_EvaluateConditionW(package,Condition) == MSICONDITION_TRUE)
1955         {
1956             int level = MSI_RecordGetInteger(row,2);
1957             TRACE("Reseting feature %s to level %i\n", debugstr_w(name), level);
1958             feature->Level = level;
1959         }
1960     }
1961     return ERROR_SUCCESS;
1962 }
1963
1964 static LPWSTR msi_get_disk_file_version( LPCWSTR filename )
1965 {
1966     static const WCHAR name_fmt[] =
1967         {'%','u','.','%','u','.','%','u','.','%','u',0};
1968     static WCHAR name[] = {'\\',0};
1969     VS_FIXEDFILEINFO *lpVer;
1970     WCHAR filever[0x100];
1971     LPVOID version;
1972     DWORD versize;
1973     DWORD handle;
1974     UINT sz;
1975
1976     TRACE("%s\n", debugstr_w(filename));
1977
1978     versize = GetFileVersionInfoSizeW( filename, &handle );
1979     if (!versize)
1980         return NULL;
1981
1982     version = msi_alloc( versize );
1983     GetFileVersionInfoW( filename, 0, versize, version );
1984
1985     if (!VerQueryValueW( version, name, (LPVOID*)&lpVer, &sz ))
1986     {
1987         msi_free( version );
1988         return NULL;
1989     }
1990
1991     sprintfW( filever, name_fmt,
1992         HIWORD(lpVer->dwFileVersionMS),
1993         LOWORD(lpVer->dwFileVersionMS),
1994         HIWORD(lpVer->dwFileVersionLS),
1995         LOWORD(lpVer->dwFileVersionLS));
1996
1997     msi_free( version );
1998
1999     return strdupW( filever );
2000 }
2001
2002 static UINT msi_check_file_install_states( MSIPACKAGE *package )
2003 {
2004     LPWSTR file_version;
2005     MSIFILE *file;
2006
2007     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2008     {
2009         MSICOMPONENT* comp = file->Component;
2010         LPWSTR p;
2011
2012         if (!comp)
2013             continue;
2014
2015         if (file->IsCompressed)
2016             comp->ForceLocalState = TRUE;
2017
2018         /* calculate target */
2019         p = resolve_folder(package, comp->Directory, FALSE, FALSE, TRUE, NULL);
2020
2021         msi_free(file->TargetPath);
2022
2023         TRACE("file %s is named %s\n",
2024                debugstr_w(file->File), debugstr_w(file->FileName));
2025
2026         file->TargetPath = build_directory_name(2, p, file->FileName);
2027
2028         msi_free(p);
2029
2030         TRACE("file %s resolves to %s\n",
2031                debugstr_w(file->File), debugstr_w(file->TargetPath));
2032
2033         /* don't check files of components that aren't installed */
2034         if (comp->Installed == INSTALLSTATE_UNKNOWN ||
2035             comp->Installed == INSTALLSTATE_ABSENT)
2036         {
2037             file->state = msifs_missing;  /* assume files are missing */
2038             continue;
2039         }
2040
2041         if (GetFileAttributesW(file->TargetPath) == INVALID_FILE_ATTRIBUTES)
2042         {
2043             file->state = msifs_missing;
2044             comp->Cost += file->FileSize;
2045             comp->Installed = INSTALLSTATE_INCOMPLETE;
2046             continue;
2047         }
2048
2049         if (file->Version &&
2050             (file_version = msi_get_disk_file_version( file->TargetPath )))
2051         {
2052             TRACE("new %s old %s\n", debugstr_w(file->Version),
2053                   debugstr_w(file_version));
2054             /* FIXME: seems like a bad way to compare version numbers */
2055             if (lstrcmpiW(file_version, file->Version)<0)
2056             {
2057                 file->state = msifs_overwrite;
2058                 comp->Cost += file->FileSize;
2059                 comp->Installed = INSTALLSTATE_INCOMPLETE;
2060             }
2061             else
2062                 file->state = msifs_present;
2063             msi_free( file_version );
2064         }
2065         else
2066             file->state = msifs_present;
2067     }
2068
2069     return ERROR_SUCCESS;
2070 }
2071
2072 /*
2073  * A lot is done in this function aside from just the costing.
2074  * The costing needs to be implemented at some point but for now I am going
2075  * to focus on the directory building
2076  *
2077  */
2078 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
2079 {
2080     static const WCHAR ExecSeqQuery[] =
2081         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2082          '`','D','i','r','e','c','t','o','r','y','`',0};
2083     static const WCHAR ConditionQuery[] =
2084         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2085          '`','C','o','n','d','i','t','i','o','n','`',0};
2086     static const WCHAR szCosting[] =
2087         {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
2088     static const WCHAR szlevel[] =
2089         {'I','N','S','T','A','L','L','L','E','V','E','L',0};
2090     static const WCHAR szOne[] = { '1', 0 };
2091     MSICOMPONENT *comp;
2092     UINT rc;
2093     MSIQUERY * view;
2094     LPWSTR level;
2095
2096     if ( 1 == msi_get_property_int( package, szCosting, 0 ) )
2097         return ERROR_SUCCESS;
2098
2099     TRACE("Building Directory properties\n");
2100
2101     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2102     if (rc == ERROR_SUCCESS)
2103     {
2104         rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeDirectories,
2105                         package);
2106         msiobj_release(&view->hdr);
2107     }
2108
2109     /* read components states from the registry */
2110     ACTION_GetComponentInstallStates(package);
2111
2112     TRACE("File calculations\n");
2113     msi_check_file_install_states( package );
2114
2115     TRACE("Evaluating Condition Table\n");
2116
2117     rc = MSI_DatabaseOpenViewW(package->db, ConditionQuery, &view);
2118     if (rc == ERROR_SUCCESS)
2119     {
2120         rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeConditions,
2121                     package);
2122         msiobj_release(&view->hdr);
2123     }
2124
2125     TRACE("Enabling or Disabling Components\n");
2126     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2127     {
2128         if (MSI_EvaluateConditionW(package, comp->Condition) == MSICONDITION_FALSE)
2129         {
2130             TRACE("Disabling component %s\n", debugstr_w(comp->Component));
2131             comp->Enabled = FALSE;
2132         }
2133     }
2134
2135     MSI_SetPropertyW(package,szCosting,szOne);
2136     /* set default run level if not set */
2137     level = msi_dup_property( package, szlevel );
2138     if (!level)
2139         MSI_SetPropertyW(package,szlevel, szOne);
2140     msi_free(level);
2141
2142     ACTION_UpdateFeatureInstallStates(package);
2143
2144     return MSI_SetFeatureStates(package);
2145 }
2146
2147 /* OK this value is "interpreted" and then formatted based on the
2148    first few characters */
2149 static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
2150                          DWORD *size)
2151 {
2152     LPSTR data = NULL;
2153     if (value[0]=='#' && value[1]!='#' && value[1]!='%')
2154     {
2155         if (value[1]=='x')
2156         {
2157             LPWSTR ptr;
2158             CHAR byte[5];
2159             LPWSTR deformated = NULL;
2160             int count;
2161
2162             deformat_string(package, &value[2], &deformated);
2163
2164             /* binary value type */
2165             ptr = deformated;
2166             *type = REG_BINARY;
2167             if (strlenW(ptr)%2)
2168                 *size = (strlenW(ptr)/2)+1;
2169             else
2170                 *size = strlenW(ptr)/2;
2171
2172             data = msi_alloc(*size);
2173
2174             byte[0] = '0';
2175             byte[1] = 'x';
2176             byte[4] = 0;
2177             count = 0;
2178             /* if uneven pad with a zero in front */
2179             if (strlenW(ptr)%2)
2180             {
2181                 byte[2]= '0';
2182                 byte[3]= *ptr;
2183                 ptr++;
2184                 data[count] = (BYTE)strtol(byte,NULL,0);
2185                 count ++;
2186                 TRACE("Uneven byte count\n");
2187             }
2188             while (*ptr)
2189             {
2190                 byte[2]= *ptr;
2191                 ptr++;
2192                 byte[3]= *ptr;
2193                 ptr++;
2194                 data[count] = (BYTE)strtol(byte,NULL,0);
2195                 count ++;
2196             }
2197             msi_free(deformated);
2198
2199             TRACE("Data %i bytes(%i)\n",*size,count);
2200         }
2201         else
2202         {
2203             LPWSTR deformated;
2204             LPWSTR p;
2205             DWORD d = 0;
2206             deformat_string(package, &value[1], &deformated);
2207
2208             *type=REG_DWORD;
2209             *size = sizeof(DWORD);
2210             data = msi_alloc(*size);
2211             p = deformated;
2212             if (*p == '-')
2213                 p++;
2214             while (*p)
2215             {
2216                 if ( (*p < '0') || (*p > '9') )
2217                     break;
2218                 d *= 10;
2219                 d += (*p - '0');
2220                 p++;
2221             }
2222             if (deformated[0] == '-')
2223                 d = -d;
2224             *(LPDWORD)data = d;
2225             TRACE("DWORD %i\n",*(LPDWORD)data);
2226
2227             msi_free(deformated);
2228         }
2229     }
2230     else
2231     {
2232         static const WCHAR szMulti[] = {'[','~',']',0};
2233         LPCWSTR ptr;
2234         *type=REG_SZ;
2235
2236         if (value[0]=='#')
2237         {
2238             if (value[1]=='%')
2239             {
2240                 ptr = &value[2];
2241                 *type=REG_EXPAND_SZ;
2242             }
2243             else
2244                 ptr = &value[1];
2245          }
2246          else
2247             ptr=value;
2248
2249         if (strstrW(value,szMulti))
2250             *type = REG_MULTI_SZ;
2251
2252         *size = deformat_string(package, ptr,(LPWSTR*)&data);
2253     }
2254     return data;
2255 }
2256
2257 static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
2258 {
2259     MSIPACKAGE *package = (MSIPACKAGE*)param;
2260     static const WCHAR szHCR[] =
2261         {'H','K','E','Y','_','C','L','A','S','S','E','S','_',
2262          'R','O','O','T','\\',0};
2263     static const WCHAR szHCU[] =
2264         {'H','K','E','Y','_','C','U','R','R','E','N','T','_',
2265          'U','S','E','R','\\',0};
2266     static const WCHAR szHLM[] =
2267         {'H','K','E','Y','_','L','O','C','A','L','_',
2268          'M','A','C','H','I','N','E','\\',0};
2269     static const WCHAR szHU[] =
2270         {'H','K','E','Y','_','U','S','E','R','S','\\',0};
2271
2272     LPSTR value_data = NULL;
2273     HKEY  root_key, hkey;
2274     DWORD type,size;
2275     LPWSTR  deformated;
2276     LPCWSTR szRoot, component, name, key, value;
2277     MSICOMPONENT *comp;
2278     MSIRECORD * uirow;
2279     LPWSTR uikey;
2280     INT   root;
2281     BOOL check_first = FALSE;
2282     UINT rc;
2283
2284     ui_progress(package,2,0,0,0);
2285
2286     value = NULL;
2287     key = NULL;
2288     uikey = NULL;
2289     name = NULL;
2290
2291     component = MSI_RecordGetString(row, 6);
2292     comp = get_loaded_component(package,component);
2293     if (!comp)
2294         return ERROR_SUCCESS;
2295
2296     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2297     {
2298         TRACE("Skipping write due to disabled component %s\n",
2299                         debugstr_w(component));
2300
2301         comp->Action = comp->Installed;
2302
2303         return ERROR_SUCCESS;
2304     }
2305
2306     comp->Action = INSTALLSTATE_LOCAL;
2307
2308     name = MSI_RecordGetString(row, 4);
2309     if( MSI_RecordIsNull(row,5) && name )
2310     {
2311         /* null values can have special meanings */
2312         if (name[0]=='-' && name[1] == 0)
2313                 return ERROR_SUCCESS;
2314         else if ((name[0]=='+' && name[1] == 0) ||
2315                  (name[0] == '*' && name[1] == 0))
2316                 name = NULL;
2317         check_first = TRUE;
2318     }
2319
2320     root = MSI_RecordGetInteger(row,2);
2321     key = MSI_RecordGetString(row, 3);
2322
2323     /* get the root key */
2324     switch (root)
2325     {
2326         case -1:
2327             {
2328                 static const WCHAR szALLUSER[] = {'A','L','L','U','S','E','R','S',0};
2329                 LPWSTR all_users = msi_dup_property( package, szALLUSER );
2330                 if (all_users && all_users[0] == '1')
2331                 {
2332                     root_key = HKEY_LOCAL_MACHINE;
2333                     szRoot = szHLM;
2334                 }
2335                 else
2336                 {
2337                     root_key = HKEY_CURRENT_USER;
2338                     szRoot = szHCU;
2339                 }
2340                 msi_free(all_users);
2341             }
2342                  break;
2343         case 0:  root_key = HKEY_CLASSES_ROOT;
2344                  szRoot = szHCR;
2345                  break;
2346         case 1:  root_key = HKEY_CURRENT_USER;
2347                  szRoot = szHCU;
2348                  break;
2349         case 2:  root_key = HKEY_LOCAL_MACHINE;
2350                  szRoot = szHLM;
2351                  break;
2352         case 3:  root_key = HKEY_USERS;
2353                  szRoot = szHU;
2354                  break;
2355         default:
2356                  ERR("Unknown root %i\n",root);
2357                  root_key=NULL;
2358                  szRoot = NULL;
2359                  break;
2360     }
2361     if (!root_key)
2362         return ERROR_SUCCESS;
2363
2364     deformat_string(package, key , &deformated);
2365     size = strlenW(deformated) + strlenW(szRoot) + 1;
2366     uikey = msi_alloc(size*sizeof(WCHAR));
2367     strcpyW(uikey,szRoot);
2368     strcatW(uikey,deformated);
2369
2370     if (RegCreateKeyW( root_key, deformated, &hkey))
2371     {
2372         ERR("Could not create key %s\n",debugstr_w(deformated));
2373         msi_free(deformated);
2374         msi_free(uikey);
2375         return ERROR_SUCCESS;
2376     }
2377     msi_free(deformated);
2378
2379     value = MSI_RecordGetString(row,5);
2380     if (value)
2381         value_data = parse_value(package, value, &type, &size);
2382     else
2383     {
2384         static const WCHAR szEmpty[] = {0};
2385         value_data = (LPSTR)strdupW(szEmpty);
2386         size = 0;
2387         type = REG_SZ;
2388     }
2389
2390     deformat_string(package, name, &deformated);
2391
2392     /* get the double nulls to terminate SZ_MULTI */
2393     if (type == REG_MULTI_SZ)
2394         size +=sizeof(WCHAR);
2395
2396     if (!check_first)
2397     {
2398         TRACE("Setting value %s of %s\n",debugstr_w(deformated),
2399                         debugstr_w(uikey));
2400         RegSetValueExW(hkey, deformated, 0, type, (LPBYTE)value_data, size);
2401     }
2402     else
2403     {
2404         DWORD sz = 0;
2405         rc = RegQueryValueExW(hkey, deformated, NULL, NULL, NULL, &sz);
2406         if (rc == ERROR_SUCCESS || rc == ERROR_MORE_DATA)
2407         {
2408             TRACE("value %s of %s checked already exists\n",
2409                             debugstr_w(deformated), debugstr_w(uikey));
2410         }
2411         else
2412         {
2413             TRACE("Checked and setting value %s of %s\n",
2414                             debugstr_w(deformated), debugstr_w(uikey));
2415             if (deformated || size)
2416                 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE) value_data, size);
2417         }
2418     }
2419     RegCloseKey(hkey);
2420
2421     uirow = MSI_CreateRecord(3);
2422     MSI_RecordSetStringW(uirow,2,deformated);
2423     MSI_RecordSetStringW(uirow,1,uikey);
2424
2425     if (type == REG_SZ)
2426         MSI_RecordSetStringW(uirow,3,(LPWSTR)value_data);
2427     else
2428         MSI_RecordSetStringW(uirow,3,value);
2429
2430     ui_actiondata(package,szWriteRegistryValues,uirow);
2431     msiobj_release( &uirow->hdr );
2432
2433     msi_free(value_data);
2434     msi_free(deformated);
2435     msi_free(uikey);
2436
2437     return ERROR_SUCCESS;
2438 }
2439
2440 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
2441 {
2442     UINT rc;
2443     MSIQUERY * view;
2444     static const WCHAR ExecSeqQuery[] =
2445         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2446          '`','R','e','g','i','s','t','r','y','`',0 };
2447
2448     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2449     if (rc != ERROR_SUCCESS)
2450         return ERROR_SUCCESS;
2451
2452     /* increment progress bar each time action data is sent */
2453     ui_progress(package,1,REG_PROGRESS_VALUE,1,0);
2454
2455     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteRegistryValues, package);
2456
2457     msiobj_release(&view->hdr);
2458     return rc;
2459 }
2460
2461 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
2462 {
2463     package->script->CurrentlyScripting = TRUE;
2464
2465     return ERROR_SUCCESS;
2466 }
2467
2468
2469 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
2470 {
2471     MSICOMPONENT *comp;
2472     DWORD progress = 0;
2473     DWORD total = 0;
2474     static const WCHAR q1[]=
2475         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
2476          '`','R','e','g','i','s','t','r','y','`',0};
2477     UINT rc;
2478     MSIQUERY * view;
2479     MSIFEATURE *feature;
2480     MSIFILE *file;
2481
2482     TRACE("InstallValidate\n");
2483
2484     rc = MSI_DatabaseOpenViewW(package->db, q1, &view);
2485     if (rc == ERROR_SUCCESS)
2486     {
2487         MSI_IterateRecords( view, &progress, NULL, package );
2488         msiobj_release( &view->hdr );
2489         total += progress * REG_PROGRESS_VALUE;
2490     }
2491
2492     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2493         total += COMPONENT_PROGRESS_VALUE;
2494
2495     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2496         total += file->FileSize;
2497
2498     ui_progress(package,0,total,0,0);
2499
2500     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2501     {
2502         TRACE("Feature: %s; Installed: %i; Action %i; Request %i\n",
2503             debugstr_w(feature->Feature), feature->Installed, feature->Action,
2504             feature->ActionRequest);
2505     }
2506
2507     return ERROR_SUCCESS;
2508 }
2509
2510 static UINT ITERATE_LaunchConditions(MSIRECORD *row, LPVOID param)
2511 {
2512     MSIPACKAGE* package = (MSIPACKAGE*)param;
2513     LPCWSTR cond = NULL;
2514     LPCWSTR message = NULL;
2515     UINT r;
2516
2517     static const WCHAR title[]=
2518         {'I','n','s','t','a','l','l',' ','F','a', 'i','l','e','d',0};
2519
2520     cond = MSI_RecordGetString(row,1);
2521
2522     r = MSI_EvaluateConditionW(package,cond);
2523     if (r == MSICONDITION_FALSE)
2524     {
2525         if ((gUILevel & INSTALLUILEVEL_MASK) != INSTALLUILEVEL_NONE)
2526         {
2527             LPWSTR deformated;
2528             message = MSI_RecordGetString(row,2);
2529             deformat_string(package,message,&deformated);
2530             MessageBoxW(NULL,deformated,title,MB_OK);
2531             msi_free(deformated);
2532         }
2533
2534         return ERROR_INSTALL_FAILURE;
2535     }
2536
2537     return ERROR_SUCCESS;
2538 }
2539
2540 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
2541 {
2542     UINT rc;
2543     MSIQUERY * view = NULL;
2544     static const WCHAR ExecSeqQuery[] =
2545         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2546          '`','L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','`',0};
2547
2548     TRACE("Checking launch conditions\n");
2549
2550     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2551     if (rc != ERROR_SUCCESS)
2552         return ERROR_SUCCESS;
2553
2554     rc = MSI_IterateRecords(view, NULL, ITERATE_LaunchConditions, package);
2555     msiobj_release(&view->hdr);
2556
2557     return rc;
2558 }
2559
2560 static LPWSTR resolve_keypath( MSIPACKAGE* package, MSICOMPONENT *cmp )
2561 {
2562
2563     if (!cmp->KeyPath)
2564         return resolve_folder(package,cmp->Directory,FALSE,FALSE,TRUE,NULL);
2565
2566     if (cmp->Attributes & msidbComponentAttributesRegistryKeyPath)
2567     {
2568         MSIRECORD * row = 0;
2569         UINT root,len;
2570         LPWSTR deformated,buffer,deformated_name;
2571         LPCWSTR key,name;
2572         static const WCHAR ExecSeqQuery[] =
2573             {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2574              '`','R','e','g','i','s','t','r','y','`',' ',
2575              'W','H','E','R','E',' ', '`','R','e','g','i','s','t','r','y','`',
2576              ' ','=',' ' ,'\'','%','s','\'',0 };
2577         static const WCHAR fmt[]={'%','0','2','i',':','\\','%','s','\\',0};
2578         static const WCHAR fmt2[]=
2579             {'%','0','2','i',':','\\','%','s','\\','%','s',0};
2580
2581         row = MSI_QueryGetRecord(package->db, ExecSeqQuery,cmp->KeyPath);
2582         if (!row)
2583             return NULL;
2584
2585         root = MSI_RecordGetInteger(row,2);
2586         key = MSI_RecordGetString(row, 3);
2587         name = MSI_RecordGetString(row, 4);
2588         deformat_string(package, key , &deformated);
2589         deformat_string(package, name, &deformated_name);
2590
2591         len = strlenW(deformated) + 6;
2592         if (deformated_name)
2593             len+=strlenW(deformated_name);
2594
2595         buffer = msi_alloc( len *sizeof(WCHAR));
2596
2597         if (deformated_name)
2598             sprintfW(buffer,fmt2,root,deformated,deformated_name);
2599         else
2600             sprintfW(buffer,fmt,root,deformated);
2601
2602         msi_free(deformated);
2603         msi_free(deformated_name);
2604         msiobj_release(&row->hdr);
2605
2606         return buffer;
2607     }
2608     else if (cmp->Attributes & msidbComponentAttributesODBCDataSource)
2609     {
2610         FIXME("UNIMPLEMENTED keypath as ODBC Source\n");
2611         return NULL;
2612     }
2613     else
2614     {
2615         MSIFILE *file = get_loaded_file( package, cmp->KeyPath );
2616
2617         if (file)
2618             return strdupW( file->TargetPath );
2619     }
2620     return NULL;
2621 }
2622
2623 static HKEY openSharedDLLsKey(void)
2624 {
2625     HKEY hkey=0;
2626     static const WCHAR path[] =
2627         {'S','o','f','t','w','a','r','e','\\',
2628          'M','i','c','r','o','s','o','f','t','\\',
2629          'W','i','n','d','o','w','s','\\',
2630          'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2631          'S','h','a','r','e','d','D','L','L','s',0};
2632
2633     RegCreateKeyW(HKEY_LOCAL_MACHINE,path,&hkey);
2634     return hkey;
2635 }
2636
2637 static UINT ACTION_GetSharedDLLsCount(LPCWSTR dll)
2638 {
2639     HKEY hkey;
2640     DWORD count=0;
2641     DWORD type;
2642     DWORD sz = sizeof(count);
2643     DWORD rc;
2644
2645     hkey = openSharedDLLsKey();
2646     rc = RegQueryValueExW(hkey, dll, NULL, &type, (LPBYTE)&count, &sz);
2647     if (rc != ERROR_SUCCESS)
2648         count = 0;
2649     RegCloseKey(hkey);
2650     return count;
2651 }
2652
2653 static UINT ACTION_WriteSharedDLLsCount(LPCWSTR path, UINT count)
2654 {
2655     HKEY hkey;
2656
2657     hkey = openSharedDLLsKey();
2658     if (count > 0)
2659         msi_reg_set_val_dword( hkey, path, count );
2660     else
2661         RegDeleteValueW(hkey,path);
2662     RegCloseKey(hkey);
2663     return count;
2664 }
2665
2666 /*
2667  * Return TRUE if the count should be written out and FALSE if not
2668  */
2669 static void ACTION_RefCountComponent( MSIPACKAGE* package, MSICOMPONENT *comp )
2670 {
2671     MSIFEATURE *feature;
2672     INT count = 0;
2673     BOOL write = FALSE;
2674
2675     /* only refcount DLLs */
2676     if (comp->KeyPath == NULL ||
2677         comp->Attributes & msidbComponentAttributesRegistryKeyPath ||
2678         comp->Attributes & msidbComponentAttributesODBCDataSource)
2679         write = FALSE;
2680     else
2681     {
2682         count = ACTION_GetSharedDLLsCount( comp->FullKeypath);
2683         write = (count > 0);
2684
2685         if (comp->Attributes & msidbComponentAttributesSharedDllRefCount)
2686             write = TRUE;
2687     }
2688
2689     /* increment counts */
2690     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2691     {
2692         ComponentList *cl;
2693
2694         if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ))
2695             continue;
2696
2697         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2698         {
2699             if ( cl->component == comp )
2700                 count++;
2701         }
2702     }
2703
2704     /* decrement counts */
2705     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2706     {
2707         ComponentList *cl;
2708
2709         if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ABSENT ))
2710             continue;
2711
2712         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2713         {
2714             if ( cl->component == comp )
2715                 count--;
2716         }
2717     }
2718
2719     /* ref count all the files in the component */
2720     if (write)
2721     {
2722         MSIFILE *file;
2723
2724         LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2725         {
2726             if (file->Component == comp)
2727                 ACTION_WriteSharedDLLsCount( file->TargetPath, count );
2728         }
2729     }
2730
2731     /* add a count for permenent */
2732     if (comp->Attributes & msidbComponentAttributesPermanent)
2733         count ++;
2734
2735     comp->RefCount = count;
2736
2737     if (write)
2738         ACTION_WriteSharedDLLsCount( comp->FullKeypath, comp->RefCount );
2739 }
2740
2741 /*
2742  * Ok further analysis makes me think that this work is
2743  * actually done in the PublishComponents and PublishFeatures
2744  * step, and not here.  It appears like the keypath and all that is
2745  * resolved in this step, however actually written in the Publish steps.
2746  * But we will leave it here for now because it is unclear
2747  */
2748 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
2749 {
2750     WCHAR squished_pc[GUID_SIZE];
2751     WCHAR squished_cc[GUID_SIZE];
2752     UINT rc;
2753     MSICOMPONENT *comp;
2754     HKEY hkey=0,hkey2=0;
2755
2756     /* writes the Component and Features values to the registry */
2757
2758     rc = MSIREG_OpenComponents(&hkey);
2759     if (rc != ERROR_SUCCESS)
2760         return rc;
2761
2762     squash_guid(package->ProductCode,squished_pc);
2763     ui_progress(package,1,COMPONENT_PROGRESS_VALUE,1,0);
2764
2765     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2766     {
2767         MSIRECORD * uirow;
2768
2769         ui_progress(package,2,0,0,0);
2770         if (!comp->ComponentId)
2771             continue;
2772
2773         squash_guid(comp->ComponentId,squished_cc);
2774
2775         msi_free(comp->FullKeypath);
2776         comp->FullKeypath = resolve_keypath( package, comp );
2777
2778         /* do the refcounting */
2779         ACTION_RefCountComponent( package, comp );
2780
2781         TRACE("Component %s (%s), Keypath=%s, RefCount=%i\n",
2782                             debugstr_w(comp->Component),
2783                             debugstr_w(squished_cc),
2784                             debugstr_w(comp->FullKeypath),
2785                             comp->RefCount);
2786         /*
2787          * Write the keypath out if the component is to be registered
2788          * and delete the key if the component is to be deregistered
2789          */
2790         if (ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2791         {
2792             rc = RegCreateKeyW(hkey,squished_cc,&hkey2);
2793             if (rc != ERROR_SUCCESS)
2794                 continue;
2795
2796             if (!comp->FullKeypath)
2797                 continue;
2798
2799             msi_reg_set_val_str( hkey2, squished_pc, comp->FullKeypath );
2800
2801             if (comp->Attributes & msidbComponentAttributesPermanent)
2802             {
2803                 static const WCHAR szPermKey[] =
2804                     { '0','0','0','0','0','0','0','0','0','0','0','0',
2805                       '0','0','0','0','0','0','0','0','0','0','0','0',
2806                       '0','0','0','0','0','0','0','0',0 };
2807
2808                 msi_reg_set_val_str( hkey2, szPermKey, comp->FullKeypath );
2809             }
2810
2811             RegCloseKey(hkey2);
2812         }
2813         else if (ACTION_VerifyComponentForAction( comp, INSTALLSTATE_ABSENT))
2814         {
2815             DWORD res;
2816
2817             rc = RegOpenKeyW(hkey,squished_cc,&hkey2);
2818             if (rc != ERROR_SUCCESS)
2819                 continue;
2820
2821             RegDeleteValueW(hkey2,squished_pc);
2822
2823             /* if the key is empty delete it */
2824             res = RegEnumKeyExW(hkey2,0,NULL,0,0,NULL,0,NULL);
2825             RegCloseKey(hkey2);
2826             if (res == ERROR_NO_MORE_ITEMS)
2827                 RegDeleteKeyW(hkey,squished_cc);
2828
2829         }
2830
2831         /* UI stuff */
2832         uirow = MSI_CreateRecord(3);
2833         MSI_RecordSetStringW(uirow,1,package->ProductCode);
2834         MSI_RecordSetStringW(uirow,2,comp->ComponentId);
2835         MSI_RecordSetStringW(uirow,3,comp->FullKeypath);
2836         ui_actiondata(package,szProcessComponents,uirow);
2837         msiobj_release( &uirow->hdr );
2838     }
2839     RegCloseKey(hkey);
2840     return rc;
2841 }
2842
2843 typedef struct {
2844     CLSID       clsid;
2845     LPWSTR      source;
2846
2847     LPWSTR      path;
2848     ITypeLib    *ptLib;
2849 } typelib_struct;
2850
2851 static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
2852                                        LPWSTR lpszName, LONG_PTR lParam)
2853 {
2854     TLIBATTR *attr;
2855     typelib_struct *tl_struct = (typelib_struct*) lParam;
2856     static const WCHAR fmt[] = {'%','s','\\','%','i',0};
2857     int sz;
2858     HRESULT res;
2859
2860     if (!IS_INTRESOURCE(lpszName))
2861     {
2862         ERR("Not Int Resource Name %s\n",debugstr_w(lpszName));
2863         return TRUE;
2864     }
2865
2866     sz = strlenW(tl_struct->source)+4;
2867     sz *= sizeof(WCHAR);
2868
2869     if ((INT_PTR)lpszName == 1)
2870         tl_struct->path = strdupW(tl_struct->source);
2871     else
2872     {
2873         tl_struct->path = msi_alloc(sz);
2874         sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName);
2875     }
2876
2877     TRACE("trying %s\n", debugstr_w(tl_struct->path));
2878     res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
2879     if (!SUCCEEDED(res))
2880     {
2881         msi_free(tl_struct->path);
2882         tl_struct->path = NULL;
2883
2884         return TRUE;
2885     }
2886
2887     ITypeLib_GetLibAttr(tl_struct->ptLib, &attr);
2888     if (IsEqualGUID(&(tl_struct->clsid),&(attr->guid)))
2889     {
2890         ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
2891         return FALSE;
2892     }
2893
2894     msi_free(tl_struct->path);
2895     tl_struct->path = NULL;
2896
2897     ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
2898     ITypeLib_Release(tl_struct->ptLib);
2899
2900     return TRUE;
2901 }
2902
2903 static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
2904 {
2905     MSIPACKAGE* package = (MSIPACKAGE*)param;
2906     LPCWSTR component;
2907     MSICOMPONENT *comp;
2908     MSIFILE *file;
2909     typelib_struct tl_struct;
2910     HMODULE module;
2911     static const WCHAR szTYPELIB[] = {'T','Y','P','E','L','I','B',0};
2912
2913     component = MSI_RecordGetString(row,3);
2914     comp = get_loaded_component(package,component);
2915     if (!comp)
2916         return ERROR_SUCCESS;
2917
2918     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2919     {
2920         TRACE("Skipping typelib reg due to disabled component\n");
2921
2922         comp->Action = comp->Installed;
2923
2924         return ERROR_SUCCESS;
2925     }
2926
2927     comp->Action = INSTALLSTATE_LOCAL;
2928
2929     file = get_loaded_file( package, comp->KeyPath );
2930     if (!file)
2931         return ERROR_SUCCESS;
2932
2933     module = LoadLibraryExW( file->TargetPath, NULL, LOAD_LIBRARY_AS_DATAFILE );
2934     if (module)
2935     {
2936         LPCWSTR guid;
2937         guid = MSI_RecordGetString(row,1);
2938         CLSIDFromString((LPWSTR)guid, &tl_struct.clsid);
2939         tl_struct.source = strdupW( file->TargetPath );
2940         tl_struct.path = NULL;
2941
2942         EnumResourceNamesW(module, szTYPELIB, Typelib_EnumResNameProc,
2943                         (LONG_PTR)&tl_struct);
2944
2945         if (tl_struct.path)
2946         {
2947             LPWSTR help = NULL;
2948             LPCWSTR helpid;
2949             HRESULT res;
2950
2951             helpid = MSI_RecordGetString(row,6);
2952
2953             if (helpid)
2954                 help = resolve_folder(package,helpid,FALSE,FALSE,TRUE,NULL);
2955             res = RegisterTypeLib(tl_struct.ptLib,tl_struct.path,help);
2956             msi_free(help);
2957
2958             if (!SUCCEEDED(res))
2959                 ERR("Failed to register type library %s\n",
2960                         debugstr_w(tl_struct.path));
2961             else
2962             {
2963                 ui_actiondata(package,szRegisterTypeLibraries,row);
2964
2965                 TRACE("Registered %s\n", debugstr_w(tl_struct.path));
2966             }
2967
2968             ITypeLib_Release(tl_struct.ptLib);
2969             msi_free(tl_struct.path);
2970         }
2971         else
2972             ERR("Failed to load type library %s\n",
2973                     debugstr_w(tl_struct.source));
2974
2975         FreeLibrary(module);
2976         msi_free(tl_struct.source);
2977     }
2978     else
2979         ERR("Could not load file! %s\n", debugstr_w(file->TargetPath));
2980
2981     return ERROR_SUCCESS;
2982 }
2983
2984 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
2985 {
2986     /*
2987      * OK this is a bit confusing.. I am given a _Component key and I believe
2988      * that the file that is being registered as a type library is the "key file
2989      * of that component" which I interpret to mean "The file in the KeyPath of
2990      * that component".
2991      */
2992     UINT rc;
2993     MSIQUERY * view;
2994     static const WCHAR Query[] =
2995         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2996          '`','T','y','p','e','L','i','b','`',0};
2997
2998     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
2999     if (rc != ERROR_SUCCESS)
3000         return ERROR_SUCCESS;
3001
3002     rc = MSI_IterateRecords(view, NULL, ITERATE_RegisterTypeLibraries, package);
3003     msiobj_release(&view->hdr);
3004     return rc;
3005 }
3006
3007 static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
3008 {
3009     MSIPACKAGE *package = (MSIPACKAGE*)param;
3010     LPWSTR target_file, target_folder, filename;
3011     LPCWSTR buffer, extension;
3012     MSICOMPONENT *comp;
3013     static const WCHAR szlnk[]={'.','l','n','k',0};
3014     IShellLinkW *sl = NULL;
3015     IPersistFile *pf = NULL;
3016     HRESULT res;
3017
3018     buffer = MSI_RecordGetString(row,4);
3019     comp = get_loaded_component(package,buffer);
3020     if (!comp)
3021         return ERROR_SUCCESS;
3022
3023     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ))
3024     {
3025         TRACE("Skipping shortcut creation due to disabled component\n");
3026
3027         comp->Action = comp->Installed;
3028
3029         return ERROR_SUCCESS;
3030     }
3031
3032     comp->Action = INSTALLSTATE_LOCAL;
3033
3034     ui_actiondata(package,szCreateShortcuts,row);
3035
3036     res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3037                     &IID_IShellLinkW, (LPVOID *) &sl );
3038
3039     if (FAILED( res ))
3040     {
3041         ERR("CLSID_ShellLink not available\n");
3042         goto err;
3043     }
3044
3045     res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
3046     if (FAILED( res ))
3047     {
3048         ERR("QueryInterface(IID_IPersistFile) failed\n");
3049         goto err;
3050     }
3051
3052     buffer = MSI_RecordGetString(row,2);
3053     target_folder = resolve_folder(package, buffer,FALSE,FALSE,TRUE,NULL);
3054
3055     /* may be needed because of a bug somehwere else */
3056     create_full_pathW(target_folder);
3057
3058     filename = msi_dup_record_field( row, 3 );
3059     reduce_to_longfilename(filename);
3060
3061     extension = strchrW(filename,'.');
3062     if (!extension || strcmpiW(extension,szlnk))
3063     {
3064         int len = strlenW(filename);
3065         filename = msi_realloc(filename, len * sizeof(WCHAR) + sizeof(szlnk));
3066         memcpy(filename + len, szlnk, sizeof(szlnk));
3067     }
3068     target_file = build_directory_name(2, target_folder, filename);
3069     msi_free(target_folder);
3070     msi_free(filename);
3071
3072     buffer = MSI_RecordGetString(row,5);
3073     if (strchrW(buffer,'['))
3074     {
3075         LPWSTR deformated;
3076         deformat_string(package,buffer,&deformated);
3077         IShellLinkW_SetPath(sl,deformated);
3078         msi_free(deformated);
3079     }
3080     else
3081     {
3082         FIXME("poorly handled shortcut format, advertised shortcut\n");
3083         IShellLinkW_SetPath(sl,comp->FullKeypath);
3084     }
3085
3086     if (!MSI_RecordIsNull(row,6))
3087     {
3088         LPWSTR deformated;
3089         buffer = MSI_RecordGetString(row,6);
3090         deformat_string(package,buffer,&deformated);
3091         IShellLinkW_SetArguments(sl,deformated);
3092         msi_free(deformated);
3093     }
3094
3095     if (!MSI_RecordIsNull(row,7))
3096     {
3097         buffer = MSI_RecordGetString(row,7);
3098         IShellLinkW_SetDescription(sl,buffer);
3099     }
3100
3101     if (!MSI_RecordIsNull(row,8))
3102         IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
3103
3104     if (!MSI_RecordIsNull(row,9))
3105     {
3106         LPWSTR Path;
3107         INT index;
3108
3109         buffer = MSI_RecordGetString(row,9);
3110
3111         Path = build_icon_path(package,buffer);
3112         index = MSI_RecordGetInteger(row,10);
3113
3114         /* no value means 0 */
3115         if (index == MSI_NULL_INTEGER)
3116             index = 0;
3117
3118         IShellLinkW_SetIconLocation(sl,Path,index);
3119         msi_free(Path);
3120     }
3121
3122     if (!MSI_RecordIsNull(row,11))
3123         IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
3124
3125     if (!MSI_RecordIsNull(row,12))
3126     {
3127         LPWSTR Path;
3128         buffer = MSI_RecordGetString(row,12);
3129         Path = resolve_folder(package, buffer, FALSE, FALSE, TRUE, NULL);
3130         if (Path)
3131             IShellLinkW_SetWorkingDirectory(sl,Path);
3132         msi_free(Path);
3133     }
3134
3135     TRACE("Writing shortcut to %s\n",debugstr_w(target_file));
3136     IPersistFile_Save(pf,target_file,FALSE);
3137
3138     msi_free(target_file);
3139
3140 err:
3141     if (pf)
3142         IPersistFile_Release( pf );
3143     if (sl)
3144         IShellLinkW_Release( sl );
3145
3146     return ERROR_SUCCESS;
3147 }
3148
3149 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
3150 {
3151     UINT rc;
3152     HRESULT res;
3153     MSIQUERY * view;
3154     static const WCHAR Query[] =
3155         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3156          '`','S','h','o','r','t','c','u','t','`',0};
3157
3158     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3159     if (rc != ERROR_SUCCESS)
3160         return ERROR_SUCCESS;
3161
3162     res = CoInitialize( NULL );
3163     if (FAILED (res))
3164     {
3165         ERR("CoInitialize failed\n");
3166         return ERROR_FUNCTION_FAILED;
3167     }
3168
3169     rc = MSI_IterateRecords(view, NULL, ITERATE_CreateShortcuts, package);
3170     msiobj_release(&view->hdr);
3171
3172     CoUninitialize();
3173
3174     return rc;
3175 }
3176
3177 static UINT ITERATE_PublishProduct(MSIRECORD *row, LPVOID param)
3178 {
3179     MSIPACKAGE* package = (MSIPACKAGE*)param;
3180     HANDLE the_file;
3181     LPWSTR FilePath;
3182     LPCWSTR FileName;
3183     CHAR buffer[1024];
3184     DWORD sz;
3185     UINT rc;
3186     MSIRECORD *uirow;
3187
3188     FileName = MSI_RecordGetString(row,1);
3189     if (!FileName)
3190     {
3191         ERR("Unable to get FileName\n");
3192         return ERROR_SUCCESS;
3193     }
3194
3195     FilePath = build_icon_path(package,FileName);
3196
3197     TRACE("Creating icon file at %s\n",debugstr_w(FilePath));
3198
3199     the_file = CreateFileW(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
3200                         FILE_ATTRIBUTE_NORMAL, NULL);
3201
3202     if (the_file == INVALID_HANDLE_VALUE)
3203     {
3204         ERR("Unable to create file %s\n",debugstr_w(FilePath));
3205         msi_free(FilePath);
3206         return ERROR_SUCCESS;
3207     }
3208
3209     do
3210     {
3211         DWORD write;
3212         sz = 1024;
3213         rc = MSI_RecordReadStream(row,2,buffer,&sz);
3214         if (rc != ERROR_SUCCESS)
3215         {
3216             ERR("Failed to get stream\n");
3217             CloseHandle(the_file);
3218             DeleteFileW(FilePath);
3219             break;
3220         }
3221         WriteFile(the_file,buffer,sz,&write,NULL);
3222     } while (sz == 1024);
3223
3224     msi_free(FilePath);
3225
3226     CloseHandle(the_file);
3227
3228     uirow = MSI_CreateRecord(1);
3229     MSI_RecordSetStringW(uirow,1,FileName);
3230     ui_actiondata(package,szPublishProduct,uirow);
3231     msiobj_release( &uirow->hdr );
3232
3233     return ERROR_SUCCESS;
3234 }
3235
3236 /*
3237  * 99% of the work done here is only done for
3238  * advertised installs. However this is where the
3239  * Icon table is processed and written out
3240  * so that is what I am going to do here.
3241  */
3242 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
3243 {
3244     UINT rc;
3245     MSIQUERY * view;
3246     static const WCHAR Query[]=
3247         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3248          '`','I','c','o','n','`',0};
3249     /* for registry stuff */
3250     HKEY hkey=0;
3251     HKEY hukey=0;
3252     HKEY hudkey=0, props=0;
3253     static const WCHAR szProductLanguage[] =
3254         {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3255     static const WCHAR szARPProductIcon[] =
3256         {'A','R','P','P','R','O','D','U','C','T','I','C','O','N',0};
3257     static const WCHAR szProductVersion[] =
3258         {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3259     static const WCHAR szInstallProperties[] =
3260         {'I','n','s','t','a','l','l','P','r','o','p','e','r','t','i','e','s',0};
3261     static const WCHAR szWindowsInstaller[] =
3262         {'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
3263     DWORD langid;
3264     LPWSTR buffer;
3265     DWORD size;
3266     MSIHANDLE hDb, hSumInfo;
3267
3268     /* write out icon files */
3269
3270     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3271     if (rc == ERROR_SUCCESS)
3272     {
3273         MSI_IterateRecords(view, NULL, ITERATE_PublishProduct, package);
3274         msiobj_release(&view->hdr);
3275     }
3276
3277     /* ok there is a lot more done here but i need to figure out what */
3278
3279     rc = MSIREG_OpenProductsKey(package->ProductCode,&hkey,TRUE);
3280     if (rc != ERROR_SUCCESS)
3281         goto end;
3282
3283     rc = MSIREG_OpenUserProductsKey(package->ProductCode,&hukey,TRUE);
3284     if (rc != ERROR_SUCCESS)
3285         goto end;
3286
3287     rc = MSIREG_OpenUserDataProductKey(package->ProductCode,&hudkey,TRUE);
3288     if (rc != ERROR_SUCCESS)
3289         goto end;
3290
3291     rc = RegCreateKeyW(hudkey, szInstallProperties, &props);
3292     if (rc != ERROR_SUCCESS)
3293         goto end;
3294
3295     msi_reg_set_val_dword( props, szWindowsInstaller, 1 );
3296
3297     buffer = msi_dup_property( package, INSTALLPROPERTY_PRODUCTNAMEW );
3298     msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTNAMEW, buffer );
3299     msi_free(buffer);
3300
3301     langid = msi_get_property_int( package, szProductLanguage, 0 );
3302     msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, langid );
3303
3304     buffer = msi_dup_property( package, szARPProductIcon );
3305     if (buffer)
3306     {
3307         LPWSTR path = build_icon_path(package,buffer);
3308         msi_reg_set_val_str( hukey, INSTALLPROPERTY_PRODUCTICONW, path );
3309         msi_free( path );
3310     }
3311     msi_free(buffer);
3312
3313     buffer = msi_dup_property( package, szProductVersion );
3314     if (buffer)
3315     {
3316         DWORD verdword = msi_version_str_to_dword(buffer);
3317         msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONW, verdword );
3318     }
3319     msi_free(buffer);
3320
3321     /* FIXME: Need to write more keys to the user registry */
3322
3323     hDb= alloc_msihandle( &package->db->hdr );
3324     if (!hDb) {
3325         rc = ERROR_NOT_ENOUGH_MEMORY;
3326         goto end;
3327     }
3328     rc = MsiGetSummaryInformationW(hDb, NULL, 0, &hSumInfo);
3329     MsiCloseHandle(hDb);
3330     if (rc == ERROR_SUCCESS)
3331     {
3332         WCHAR guidbuffer[0x200];
3333         size = 0x200;
3334         rc = MsiSummaryInfoGetPropertyW(hSumInfo, 9, NULL, NULL, NULL,
3335                                         guidbuffer, &size);
3336         if (rc == ERROR_SUCCESS)
3337         {
3338             WCHAR squashed[GUID_SIZE];
3339             /* for now we only care about the first guid */
3340             LPWSTR ptr = strchrW(guidbuffer,';');
3341             if (ptr) *ptr = 0;
3342             squash_guid(guidbuffer,squashed);
3343             msi_reg_set_val_str( hukey, INSTALLPROPERTY_PACKAGECODEW, squashed );
3344         }
3345         else
3346         {
3347             ERR("Unable to query Revision_Number...\n");
3348             rc = ERROR_SUCCESS;
3349         }
3350         MsiCloseHandle(hSumInfo);
3351     }
3352     else
3353     {
3354         ERR("Unable to open Summary Information\n");
3355         rc = ERROR_SUCCESS;
3356     }
3357
3358 end:
3359     RegCloseKey(hkey);
3360     RegCloseKey(hukey);
3361     RegCloseKey(hudkey);
3362     RegCloseKey(props);
3363
3364     return rc;
3365 }
3366
3367 static UINT ITERATE_WriteIniValues(MSIRECORD *row, LPVOID param)
3368 {
3369     MSIPACKAGE *package = (MSIPACKAGE*)param;
3370     LPCWSTR component,section,key,value,identifier,filename,dirproperty;
3371     LPWSTR deformated_section, deformated_key, deformated_value;
3372     LPWSTR folder, fullname = NULL;
3373     MSIRECORD * uirow;
3374     INT action;
3375     MSICOMPONENT *comp;
3376     static const WCHAR szWindowsFolder[] =
3377           {'W','i','n','d','o','w','s','F','o','l','d','e','r',0};
3378
3379     component = MSI_RecordGetString(row, 8);
3380     comp = get_loaded_component(package,component);
3381
3382     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
3383     {
3384         TRACE("Skipping ini file due to disabled component %s\n",
3385                         debugstr_w(component));
3386
3387         comp->Action = comp->Installed;
3388
3389         return ERROR_SUCCESS;
3390     }
3391
3392     comp->Action = INSTALLSTATE_LOCAL;
3393
3394     identifier = MSI_RecordGetString(row,1);
3395     filename = MSI_RecordGetString(row,2);
3396     dirproperty = MSI_RecordGetString(row,3);
3397     section = MSI_RecordGetString(row,4);
3398     key = MSI_RecordGetString(row,5);
3399     value = MSI_RecordGetString(row,6);
3400     action = MSI_RecordGetInteger(row,7);
3401
3402     deformat_string(package,section,&deformated_section);
3403     deformat_string(package,key,&deformated_key);
3404     deformat_string(package,value,&deformated_value);
3405
3406     if (dirproperty)
3407     {
3408         folder = resolve_folder(package, dirproperty, FALSE, FALSE, TRUE, NULL);
3409         if (!folder)
3410             folder = msi_dup_property( package, dirproperty );
3411     }
3412     else
3413         folder = msi_dup_property( package, szWindowsFolder );
3414
3415     if (!folder)
3416     {
3417         ERR("Unable to resolve folder! (%s)\n",debugstr_w(dirproperty));
3418         goto cleanup;
3419     }
3420
3421     fullname = build_directory_name(2, folder, filename);
3422
3423     if (action == 0)
3424     {
3425         TRACE("Adding value %s to section %s in %s\n",
3426                 debugstr_w(deformated_key), debugstr_w(deformated_section),
3427                 debugstr_w(fullname));
3428         WritePrivateProfileStringW(deformated_section, deformated_key,
3429                                    deformated_value, fullname);
3430     }
3431     else if (action == 1)
3432     {
3433         WCHAR returned[10];
3434         GetPrivateProfileStringW(deformated_section, deformated_key, NULL,
3435                                  returned, 10, fullname);
3436         if (returned[0] == 0)
3437         {
3438             TRACE("Adding value %s to section %s in %s\n",
3439                     debugstr_w(deformated_key), debugstr_w(deformated_section),
3440                     debugstr_w(fullname));
3441
3442             WritePrivateProfileStringW(deformated_section, deformated_key,
3443                                        deformated_value, fullname);
3444         }
3445     }
3446     else if (action == 3)
3447         FIXME("Append to existing section not yet implemented\n");
3448
3449     uirow = MSI_CreateRecord(4);
3450     MSI_RecordSetStringW(uirow,1,identifier);
3451     MSI_RecordSetStringW(uirow,2,deformated_section);
3452     MSI_RecordSetStringW(uirow,3,deformated_key);
3453     MSI_RecordSetStringW(uirow,4,deformated_value);
3454     ui_actiondata(package,szWriteIniValues,uirow);
3455     msiobj_release( &uirow->hdr );
3456 cleanup:
3457     msi_free(fullname);
3458     msi_free(folder);
3459     msi_free(deformated_key);
3460     msi_free(deformated_value);
3461     msi_free(deformated_section);
3462     return ERROR_SUCCESS;
3463 }
3464
3465 static UINT ACTION_WriteIniValues(MSIPACKAGE *package)
3466 {
3467     UINT rc;
3468     MSIQUERY * view;
3469     static const WCHAR ExecSeqQuery[] =
3470         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3471          '`','I','n','i','F','i','l','e','`',0};
3472
3473     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3474     if (rc != ERROR_SUCCESS)
3475     {
3476         TRACE("no IniFile table\n");
3477         return ERROR_SUCCESS;
3478     }
3479
3480     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteIniValues, package);
3481     msiobj_release(&view->hdr);
3482     return rc;
3483 }
3484
3485 static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
3486 {
3487     MSIPACKAGE *package = (MSIPACKAGE*)param;
3488     LPCWSTR filename;
3489     LPWSTR FullName;
3490     MSIFILE *file;
3491     DWORD len;
3492     static const WCHAR ExeStr[] =
3493         {'r','e','g','s','v','r','3','2','.','e','x','e',' ','\"',0};
3494     static const WCHAR close[] =  {'\"',0};
3495     STARTUPINFOW si;
3496     PROCESS_INFORMATION info;
3497     BOOL brc;
3498     MSIRECORD *uirow;
3499     LPWSTR uipath, p;
3500
3501     memset(&si,0,sizeof(STARTUPINFOW));
3502
3503     filename = MSI_RecordGetString(row,1);
3504     file = get_loaded_file( package, filename );
3505
3506     if (!file)
3507     {
3508         ERR("Unable to find file id %s\n",debugstr_w(filename));
3509         return ERROR_SUCCESS;
3510     }
3511
3512     len = strlenW(ExeStr) + strlenW( file->TargetPath ) + 2;
3513
3514     FullName = msi_alloc(len*sizeof(WCHAR));
3515     strcpyW(FullName,ExeStr);
3516     strcatW( FullName, file->TargetPath );
3517     strcatW(FullName,close);
3518
3519     TRACE("Registering %s\n",debugstr_w(FullName));
3520     brc = CreateProcessW(NULL, FullName, NULL, NULL, FALSE, 0, NULL, c_colon,
3521                     &si, &info);
3522
3523     if (brc)
3524         msi_dialog_check_messages(info.hProcess);
3525
3526     msi_free(FullName);
3527
3528     /* the UI chunk */
3529     uirow = MSI_CreateRecord( 2 );
3530     uipath = strdupW( file->TargetPath );
3531     p = strrchrW(uipath,'\\');
3532     if (p)
3533         p[0]=0;
3534     MSI_RecordSetStringW( uirow, 1, &p[1] );
3535     MSI_RecordSetStringW( uirow, 2, uipath);
3536     ui_actiondata( package, szSelfRegModules, uirow);
3537     msiobj_release( &uirow->hdr );
3538     msi_free( uipath );
3539     /* FIXME: call ui_progress? */
3540
3541     return ERROR_SUCCESS;
3542 }
3543
3544 static UINT ACTION_SelfRegModules(MSIPACKAGE *package)
3545 {
3546     UINT rc;
3547     MSIQUERY * view;
3548     static const WCHAR ExecSeqQuery[] =
3549         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3550          '`','S','e','l','f','R','e','g','`',0};
3551
3552     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3553     if (rc != ERROR_SUCCESS)
3554     {
3555         TRACE("no SelfReg table\n");
3556         return ERROR_SUCCESS;
3557     }
3558
3559     MSI_IterateRecords(view, NULL, ITERATE_SelfRegModules, package);
3560     msiobj_release(&view->hdr);
3561
3562     return ERROR_SUCCESS;
3563 }
3564
3565 static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
3566 {
3567     MSIFEATURE *feature;
3568     UINT rc;
3569     HKEY hkey=0;
3570     HKEY hukey=0;
3571
3572     rc = MSIREG_OpenFeaturesKey(package->ProductCode,&hkey,TRUE);
3573     if (rc != ERROR_SUCCESS)
3574         goto end;
3575
3576     rc = MSIREG_OpenUserFeaturesKey(package->ProductCode,&hukey,TRUE);
3577     if (rc != ERROR_SUCCESS)
3578         goto end;
3579
3580     /* here the guids are base 85 encoded */
3581     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3582     {
3583         ComponentList *cl;
3584         LPWSTR data = NULL;
3585         GUID clsid;
3586         INT size;
3587         BOOL absent = FALSE;
3588         MSIRECORD *uirow;
3589
3590         if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ) &&
3591             !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_SOURCE ) &&
3592             !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ADVERTISED ))
3593             absent = TRUE;
3594
3595         size = 1;
3596         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3597         {
3598             size += 21;
3599         }
3600         if (feature->Feature_Parent)
3601             size += strlenW( feature->Feature_Parent )+2;
3602
3603         data = msi_alloc(size * sizeof(WCHAR));
3604
3605         data[0] = 0;
3606         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3607         {
3608             MSICOMPONENT* component = cl->component;
3609             WCHAR buf[21];
3610
3611             buf[0] = 0;
3612             if (component->ComponentId)
3613             {
3614                 TRACE("From %s\n",debugstr_w(component->ComponentId));
3615                 CLSIDFromString(component->ComponentId, &clsid);
3616                 encode_base85_guid(&clsid,buf);
3617                 TRACE("to %s\n",debugstr_w(buf));
3618                 strcatW(data,buf);
3619             }
3620         }
3621         if (feature->Feature_Parent)
3622         {
3623             static const WCHAR sep[] = {'\2',0};
3624             strcatW(data,sep);
3625             strcatW(data,feature->Feature_Parent);
3626         }
3627
3628         msi_reg_set_val_str( hkey, feature->Feature, data );
3629         msi_free(data);
3630
3631         size = 0;
3632         if (feature->Feature_Parent)
3633             size = strlenW(feature->Feature_Parent)*sizeof(WCHAR);
3634         if (!absent)
3635         {
3636             RegSetValueExW(hukey,feature->Feature,0,REG_SZ,
3637                        (LPBYTE)feature->Feature_Parent,size);
3638         }
3639         else
3640         {
3641             size += 2*sizeof(WCHAR);
3642             data = msi_alloc(size);
3643             data[0] = 0x6;
3644             data[1] = 0;
3645             if (feature->Feature_Parent)
3646                 strcpyW( &data[1], feature->Feature_Parent );
3647             RegSetValueExW(hukey,feature->Feature,0,REG_SZ,
3648                        (LPBYTE)data,size);
3649             msi_free(data);
3650         }
3651
3652         /* the UI chunk */
3653         uirow = MSI_CreateRecord( 1 );
3654         MSI_RecordSetStringW( uirow, 1, feature->Feature );
3655         ui_actiondata( package, szPublishFeatures, uirow);
3656         msiobj_release( &uirow->hdr );
3657         /* FIXME: call ui_progress? */
3658     }
3659
3660 end:
3661     RegCloseKey(hkey);
3662     RegCloseKey(hukey);
3663     return rc;
3664 }
3665
3666 static UINT msi_get_local_package_name( LPWSTR path )
3667 {
3668     static const WCHAR szInstaller[] = {
3669         '\\','I','n','s','t','a','l','l','e','r','\\',0};
3670     static const WCHAR fmt[] = { '%','x','.','m','s','i',0};
3671     DWORD time, len, i;
3672     HANDLE handle;
3673
3674     time = GetTickCount();
3675     GetWindowsDirectoryW( path, MAX_PATH );
3676     lstrcatW( path, szInstaller );
3677     CreateDirectoryW( path, NULL );
3678
3679     len = lstrlenW(path);
3680     for (i=0; i<0x10000; i++)
3681     {
3682         snprintfW( &path[len], MAX_PATH - len, fmt, (time+i)&0xffff );
3683         handle = CreateFileW( path, GENERIC_WRITE, 0, NULL,
3684                               CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
3685         if (handle != INVALID_HANDLE_VALUE)
3686         {
3687             CloseHandle(handle);
3688             break;
3689         }
3690         if (GetLastError() != ERROR_FILE_EXISTS &&
3691             GetLastError() != ERROR_SHARING_VIOLATION)
3692             return ERROR_FUNCTION_FAILED;
3693     }
3694
3695     return ERROR_SUCCESS;
3696 }
3697
3698 static UINT msi_make_package_local( MSIPACKAGE *package, HKEY hkey )
3699 {
3700     static const WCHAR szOriginalDatabase[] =
3701         {'O','r','i','g','i','n','a','l','D','a','t','a','b','a','s','e',0};
3702     WCHAR packagefile[MAX_PATH];
3703     LPWSTR msiFilePath;
3704     UINT r;
3705
3706     r = msi_get_local_package_name( packagefile );
3707     if (r != ERROR_SUCCESS)
3708         return r;
3709
3710     TRACE("Copying to local package %s\n",debugstr_w(packagefile));
3711
3712     msiFilePath = msi_dup_property( package, szOriginalDatabase );
3713     r = CopyFileW( msiFilePath, packagefile, FALSE);
3714
3715     if (!r)
3716     {
3717         ERR("Unable to copy package (%s -> %s) (error %d)\n",
3718             debugstr_w(msiFilePath), debugstr_w(packagefile), GetLastError());
3719         msi_free( msiFilePath );
3720         return ERROR_FUNCTION_FAILED;
3721     }
3722     msi_free( msiFilePath );
3723
3724     /* FIXME: maybe set this key in ACTION_RegisterProduct instead */
3725     msi_reg_set_val_str( hkey, INSTALLPROPERTY_LOCALPACKAGEW, packagefile );
3726     return ERROR_SUCCESS;
3727 }
3728
3729 static UINT msi_write_uninstall_property_vals( MSIPACKAGE *package, HKEY hkey )
3730 {
3731     LPWSTR prop, val, key;
3732     static const LPCSTR propval[] = {
3733         "ARPAUTHORIZEDCDFPREFIX", "AuthorizedCDFPrefix",
3734         "ARPCONTACT",             "Contact",
3735         "ARPCOMMENTS",            "Comments",
3736         "ProductName",            "DisplayName",
3737         "ProductVersion",         "DisplayVersion",
3738         "ARPHELPLINK",            "HelpLink",
3739         "ARPHELPTELEPHONE",       "HelpTelephone",
3740         "ARPINSTALLLOCATION",     "InstallLocation",
3741         "SourceDir",              "InstallSource",
3742         "Manufacturer",           "Publisher",
3743         "ARPREADME",              "Readme",
3744         "ARPSIZE",                "Size",
3745         "ARPURLINFOABOUT",        "URLInfoAbout",
3746         "ARPURLUPDATEINFO",       "URLUpdateInfo",
3747         NULL,
3748     };
3749     const LPCSTR *p = propval;
3750
3751     while( *p )
3752     {
3753         prop = strdupAtoW( *p++ );
3754         key = strdupAtoW( *p++ );
3755         val = msi_dup_property( package, prop );
3756         msi_reg_set_val_str( hkey, key, val );
3757         msi_free(val);
3758         msi_free(key);
3759         msi_free(prop);
3760     }
3761     return ERROR_SUCCESS;
3762 }
3763
3764 static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
3765 {
3766     HKEY hkey=0;
3767     LPWSTR buffer = NULL;
3768     UINT rc;
3769     DWORD size, langid;
3770     static const WCHAR szWindowsInstaller[] =
3771         {'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
3772     static const WCHAR szUpgradeCode[] =
3773         {'U','p','g','r','a','d','e','C','o','d','e',0};
3774     static const WCHAR modpath_fmt[] =
3775         {'M','s','i','E','x','e','c','.','e','x','e',' ',
3776          '/','I','[','P','r','o','d','u','c','t','C','o','d','e',']',0};
3777     static const WCHAR szModifyPath[] =
3778         {'M','o','d','i','f','y','P','a','t','h',0};
3779     static const WCHAR szUninstallString[] =
3780         {'U','n','i','n','s','t','a','l','l','S','t','r','i','n','g',0};
3781     static const WCHAR szEstimatedSize[] =
3782         {'E','s','t','i','m','a','t','e','d','S','i','z','e',0};
3783     static const WCHAR szProductLanguage[] =
3784         {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3785     static const WCHAR szProductVersion[] =
3786         {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3787
3788     SYSTEMTIME systime;
3789     static const WCHAR date_fmt[] = {'%','i','%','i','%','i',0};
3790     LPWSTR upgrade_code;
3791     WCHAR szDate[9];
3792
3793     rc = MSIREG_OpenUninstallKey(package->ProductCode,&hkey,TRUE);
3794     if (rc != ERROR_SUCCESS)
3795         return rc;
3796
3797     /* dump all the info i can grab */
3798     /* FIXME: Flesh out more information */
3799
3800     msi_write_uninstall_property_vals( package, hkey );
3801
3802     msi_reg_set_val_dword( hkey, szWindowsInstaller, 1 );
3803
3804     msi_make_package_local( package, hkey );
3805
3806     /* do ModifyPath and UninstallString */
3807     size = deformat_string(package,modpath_fmt,&buffer);
3808     RegSetValueExW(hkey,szModifyPath,0,REG_EXPAND_SZ,(LPBYTE)buffer,size);
3809     RegSetValueExW(hkey,szUninstallString,0,REG_EXPAND_SZ,(LPBYTE)buffer,size);
3810     msi_free(buffer);
3811
3812     /* FIXME: Write real Estimated Size when we have it */
3813     msi_reg_set_val_dword( hkey, szEstimatedSize, 0 );
3814
3815     GetLocalTime(&systime);
3816     sprintfW(szDate,date_fmt,systime.wYear,systime.wMonth,systime.wDay);
3817     msi_reg_set_val_str( hkey, INSTALLPROPERTY_INSTALLDATEW, szDate );
3818
3819     langid = msi_get_property_int( package, szProductLanguage, 0 );
3820     msi_reg_set_val_dword( hkey, INSTALLPROPERTY_LANGUAGEW, langid );
3821
3822     buffer = msi_dup_property( package, szProductVersion );
3823     if (buffer)
3824     {
3825         DWORD verdword = msi_version_str_to_dword(buffer);
3826
3827         msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONW, verdword );
3828         msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword>>24 );
3829         msi_reg_set_val_dword( hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword>>16)&0x00FF );
3830     }
3831     msi_free(buffer);
3832
3833     /* Handle Upgrade Codes */
3834     upgrade_code = msi_dup_property( package, szUpgradeCode );
3835     if (upgrade_code)
3836     {
3837         HKEY hkey2;
3838         WCHAR squashed[33];
3839         MSIREG_OpenUpgradeCodesKey(upgrade_code, &hkey2, TRUE);
3840         squash_guid(package->ProductCode,squashed);
3841         msi_reg_set_val_str( hkey2, squashed, NULL );
3842         RegCloseKey(hkey2);
3843         MSIREG_OpenUserUpgradeCodesKey(upgrade_code, &hkey2, TRUE);
3844         squash_guid(package->ProductCode,squashed);
3845         msi_reg_set_val_str( hkey2, squashed, NULL );
3846         RegCloseKey(hkey2);
3847
3848         msi_free(upgrade_code);
3849     }
3850
3851     RegCloseKey(hkey);
3852
3853     /* FIXME: call ui_actiondata */
3854
3855     return ERROR_SUCCESS;
3856 }
3857
3858 static UINT ACTION_InstallExecute(MSIPACKAGE *package)
3859 {
3860     return execute_script(package,INSTALL_SCRIPT);
3861 }
3862
3863 static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
3864 {
3865     UINT rc;
3866
3867     /* turn off scheduling */
3868     package->script->CurrentlyScripting= FALSE;
3869
3870     /* first do the same as an InstallExecute */
3871     rc = ACTION_InstallExecute(package);
3872     if (rc != ERROR_SUCCESS)
3873         return rc;
3874
3875     /* then handle Commit Actions */
3876     rc = execute_script(package,COMMIT_SCRIPT);
3877
3878     return rc;
3879 }
3880
3881 UINT ACTION_ForceReboot(MSIPACKAGE *package)
3882 {
3883     static const WCHAR RunOnce[] = {
3884     'S','o','f','t','w','a','r','e','\\',
3885     'M','i','c','r','o','s','o','f','t','\\',
3886     'W','i','n','d','o','w','s','\\',
3887     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3888     'R','u','n','O','n','c','e',0};
3889     static const WCHAR InstallRunOnce[] = {
3890     'S','o','f','t','w','a','r','e','\\',
3891     'M','i','c','r','o','s','o','f','t','\\',
3892     'W','i','n','d','o','w','s','\\',
3893     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
3894     'I','n','s','t','a','l','l','e','r','\\',
3895     'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0};
3896
3897     static const WCHAR msiexec_fmt[] = {
3898     '%','s',
3899     '\\','M','s','i','E','x','e','c','.','e','x','e',' ','/','@',' ',
3900     '\"','%','s','\"',0};
3901     static const WCHAR install_fmt[] = {
3902     '/','I',' ','\"','%','s','\"',' ',
3903     'A','F','T','E','R','R','E','B','O','O','T','=','1',' ',
3904     'R','U','N','O','N','C','E','E','N','T','R','Y','=','\"','%','s','\"',0};
3905     WCHAR buffer[256], sysdir[MAX_PATH];
3906     HKEY hkey;
3907     WCHAR squished_pc[100];
3908
3909     squash_guid(package->ProductCode,squished_pc);
3910
3911     GetSystemDirectoryW(sysdir, sizeof(sysdir)/sizeof(sysdir[0]));
3912     RegCreateKeyW(HKEY_LOCAL_MACHINE,RunOnce,&hkey);
3913     snprintfW(buffer,sizeof(buffer)/sizeof(buffer[0]),msiexec_fmt,sysdir,
3914      squished_pc);
3915
3916     msi_reg_set_val_str( hkey, squished_pc, buffer );
3917     RegCloseKey(hkey);
3918
3919     TRACE("Reboot command %s\n",debugstr_w(buffer));
3920
3921     RegCreateKeyW(HKEY_LOCAL_MACHINE,InstallRunOnce,&hkey);
3922     sprintfW(buffer,install_fmt,package->ProductCode,squished_pc);
3923
3924     msi_reg_set_val_str( hkey, squished_pc, buffer );
3925     RegCloseKey(hkey);
3926
3927     return ERROR_INSTALL_SUSPEND;
3928 }
3929
3930 static UINT msi_set_sourcedir_props(MSIPACKAGE *package)
3931 {
3932     LPWSTR p, source;
3933     DWORD len;
3934
3935     p = strrchrW( package->PackagePath, '\\' );
3936     if (!p)
3937         return ERROR_SUCCESS;
3938
3939     len = p - package->PackagePath + 2;
3940     source = msi_alloc( len * sizeof(WCHAR) );
3941     lstrcpynW( source, package->PackagePath, len );
3942
3943     MSI_SetPropertyW( package, cszSourceDir, source );
3944     MSI_SetPropertyW( package, cszSOURCEDIR, source );
3945
3946     msi_free( source );
3947
3948     return ERROR_SUCCESS;
3949 }
3950
3951 static UINT ACTION_ResolveSource(MSIPACKAGE* package)
3952 {
3953     DWORD attrib;
3954     UINT rc;
3955
3956     /*
3957      * We are currently doing what should be done here in the top level Install
3958      * however for Administrative and uninstalls this step will be needed
3959      */
3960     if (!package->PackagePath)
3961         return ERROR_SUCCESS;
3962
3963     msi_set_sourcedir_props(package);
3964
3965     attrib = GetFileAttributesW(package->PackagePath);
3966     if (attrib == INVALID_FILE_ATTRIBUTES)
3967     {
3968         LPWSTR prompt;
3969         LPWSTR msg;
3970         DWORD size = 0;
3971
3972         rc = MsiSourceListGetInfoW(package->ProductCode, NULL,
3973                 MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT,
3974                 INSTALLPROPERTY_DISKPROMPTW,NULL,&size);
3975         if (rc == ERROR_MORE_DATA)
3976         {
3977             prompt = msi_alloc(size * sizeof(WCHAR));
3978             MsiSourceListGetInfoW(package->ProductCode, NULL,
3979                     MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT,
3980                     INSTALLPROPERTY_DISKPROMPTW,prompt,&size);
3981         }
3982         else
3983             prompt = strdupW(package->PackagePath);
3984
3985         msg = generate_error_string(package,1302,1,prompt);
3986         while(attrib == INVALID_FILE_ATTRIBUTES)
3987         {
3988             rc = MessageBoxW(NULL,msg,NULL,MB_OKCANCEL);
3989             if (rc == IDCANCEL)
3990             {
3991                 rc = ERROR_INSTALL_USEREXIT;
3992                 break;
3993             }
3994             attrib = GetFileAttributesW(package->PackagePath);
3995         }
3996         msi_free(prompt);
3997         rc = ERROR_SUCCESS;
3998     }
3999     else
4000         return ERROR_SUCCESS;
4001
4002     return rc;
4003 }
4004
4005 static UINT ACTION_RegisterUser(MSIPACKAGE *package)
4006 {
4007     HKEY hkey=0;
4008     LPWSTR buffer;
4009     LPWSTR productid;
4010     UINT rc,i;
4011
4012     static const WCHAR szPropKeys[][80] =
4013     {
4014         {'P','r','o','d','u','c','t','I','D',0},
4015         {'U','S','E','R','N','A','M','E',0},
4016         {'C','O','M','P','A','N','Y','N','A','M','E',0},
4017         {0},
4018     };
4019
4020     static const WCHAR szRegKeys[][80] =
4021     {
4022         {'P','r','o','d','u','c','t','I','D',0},
4023         {'R','e','g','O','w','n','e','r',0},
4024         {'R','e','g','C','o','m','p','a','n','y',0},
4025         {0},
4026     };
4027
4028     productid = msi_dup_property( package, INSTALLPROPERTY_PRODUCTIDW );
4029     if (!productid)
4030         return ERROR_SUCCESS;
4031
4032     rc = MSIREG_OpenUninstallKey(package->ProductCode,&hkey,TRUE);
4033     if (rc != ERROR_SUCCESS)
4034         goto end;
4035
4036     for( i = 0; szPropKeys[i][0]; i++ )
4037     {
4038         buffer = msi_dup_property( package, szPropKeys[i] );
4039         msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
4040         msi_free( buffer );
4041     }
4042
4043 end:
4044     msi_free(productid);
4045     RegCloseKey(hkey);
4046
4047     /* FIXME: call ui_actiondata */
4048
4049     return ERROR_SUCCESS;
4050 }
4051
4052
4053 static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
4054 {
4055     UINT rc;
4056
4057     package->script->InWhatSequence |= SEQUENCE_EXEC;
4058     rc = ACTION_ProcessExecSequence(package,FALSE);
4059     return rc;
4060 }
4061
4062
4063 static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
4064 {
4065     MSIPACKAGE *package = (MSIPACKAGE*)param;
4066     LPCWSTR compgroupid=NULL;
4067     LPCWSTR feature=NULL;
4068     LPCWSTR text = NULL;
4069     LPCWSTR qualifier = NULL;
4070     LPCWSTR component = NULL;
4071     LPWSTR advertise = NULL;
4072     LPWSTR output = NULL;
4073     HKEY hkey;
4074     UINT rc = ERROR_SUCCESS;
4075     MSICOMPONENT *comp;
4076     DWORD sz = 0;
4077     MSIRECORD *uirow;
4078
4079     component = MSI_RecordGetString(rec,3);
4080     comp = get_loaded_component(package,component);
4081
4082     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ) &&
4083        !ACTION_VerifyComponentForAction( comp, INSTALLSTATE_SOURCE ) &&
4084        !ACTION_VerifyComponentForAction( comp, INSTALLSTATE_ADVERTISED ))
4085     {
4086         TRACE("Skipping: Component %s not scheduled for install\n",
4087                         debugstr_w(component));
4088
4089         return ERROR_SUCCESS;
4090     }
4091
4092     compgroupid = MSI_RecordGetString(rec,1);
4093     qualifier = MSI_RecordGetString(rec,2);
4094
4095     rc = MSIREG_OpenUserComponentsKey(compgroupid, &hkey, TRUE);
4096     if (rc != ERROR_SUCCESS)
4097         goto end;
4098
4099     text = MSI_RecordGetString(rec,4);
4100     feature = MSI_RecordGetString(rec,5);
4101
4102     advertise = create_component_advertise_string(package, comp, feature);
4103
4104     sz = strlenW(advertise);
4105
4106     if (text)
4107         sz += lstrlenW(text);
4108
4109     sz+=3;
4110     sz *= sizeof(WCHAR);
4111
4112     output = msi_alloc_zero(sz);
4113     strcpyW(output,advertise);
4114     msi_free(advertise);
4115
4116     if (text)
4117         strcatW(output,text);
4118
4119     msi_reg_set_val_multi_str( hkey, qualifier, output );
4120
4121 end:
4122     RegCloseKey(hkey);
4123     msi_free(output);
4124
4125     /* the UI chunk */
4126     uirow = MSI_CreateRecord( 2 );
4127     MSI_RecordSetStringW( uirow, 1, compgroupid );
4128     MSI_RecordSetStringW( uirow, 2, qualifier);
4129     ui_actiondata( package, szPublishComponents, uirow);
4130     msiobj_release( &uirow->hdr );
4131     /* FIXME: call ui_progress? */
4132
4133     return rc;
4134 }
4135
4136 /*
4137  * At present I am ignorning the advertised components part of this and only
4138  * focusing on the qualified component sets
4139  */
4140 static UINT ACTION_PublishComponents(MSIPACKAGE *package)
4141 {
4142     UINT rc;
4143     MSIQUERY * view;
4144     static const WCHAR ExecSeqQuery[] =
4145         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4146          '`','P','u','b','l','i','s','h',
4147          'C','o','m','p','o','n','e','n','t','`',0};
4148
4149     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4150     if (rc != ERROR_SUCCESS)
4151         return ERROR_SUCCESS;
4152
4153     rc = MSI_IterateRecords(view, NULL, ITERATE_PublishComponent, package);
4154     msiobj_release(&view->hdr);
4155
4156     return rc;
4157 }
4158
4159 static UINT ITERATE_InstallService(MSIRECORD *rec, LPVOID param)
4160 {
4161     MSIPACKAGE *package = (MSIPACKAGE*)param;
4162     MSIRECORD *row;
4163     MSIFILE *file;
4164     SC_HANDLE hscm, service = NULL;
4165     LPCWSTR name, disp, comp, depends, pass;
4166     LPCWSTR load_order, serv_name, key;
4167     DWORD serv_type, start_type;
4168     DWORD err_control;
4169
4170     static const WCHAR query[] =
4171         {'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
4172          '`','C','o','m','p','o','n','e','n','t','`',' ',
4173          'W','H','E','R','E',' ',
4174          '`','C','o','m','p','o','n','e','n','t','`',' ',
4175          '=','\'','%','s','\'',0};
4176
4177     hscm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, GENERIC_WRITE);
4178     if (!hscm)
4179     {
4180         ERR("Failed to open the SC Manager!\n");
4181         goto done;
4182     }
4183
4184     start_type = MSI_RecordGetInteger(rec, 5);
4185     if (start_type == SERVICE_BOOT_START || start_type == SERVICE_SYSTEM_START)
4186         goto done;
4187
4188     depends = MSI_RecordGetString(rec, 8);
4189     if (depends && *depends)
4190         FIXME("Dependency list unhandled!\n");
4191
4192     name = MSI_RecordGetString(rec, 2);
4193     disp = MSI_RecordGetString(rec, 3);
4194     serv_type = MSI_RecordGetInteger(rec, 4);
4195     err_control = MSI_RecordGetInteger(rec, 6);
4196     load_order = MSI_RecordGetString(rec, 7);
4197     serv_name = MSI_RecordGetString(rec, 9);
4198     pass = MSI_RecordGetString(rec, 10);
4199     comp = MSI_RecordGetString(rec, 12);
4200
4201     /* fetch the service path */
4202     row = MSI_QueryGetRecord(package->db, query, comp);
4203     if (!row)
4204     {
4205         ERR("Control query failed!\n");
4206         goto done;
4207     }
4208
4209     key = MSI_RecordGetString(row, 6);
4210     msiobj_release(&row->hdr);
4211
4212     file = get_loaded_file(package, key);
4213     if (!file)
4214     {
4215         ERR("Failed to load the service file\n");
4216         goto done;
4217     }
4218
4219     service = CreateServiceW(hscm, name, disp, GENERIC_ALL, serv_type,
4220                              start_type, err_control, file->TargetPath,
4221                              load_order, NULL, NULL, serv_name, pass);
4222     if (!service)
4223     {
4224         if (GetLastError() != ERROR_SERVICE_EXISTS)
4225             ERR("Failed to create service %s: %d\n", debugstr_w(name), GetLastError());
4226     }
4227
4228 done:
4229     CloseServiceHandle(service);
4230     CloseServiceHandle(hscm);
4231
4232     return ERROR_SUCCESS;
4233 }
4234
4235 static UINT ACTION_InstallServices( MSIPACKAGE *package )
4236 {
4237     UINT rc;
4238     MSIQUERY * view;
4239     static const WCHAR ExecSeqQuery[] =
4240         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4241          'S','e','r','v','i','c','e','I','n','s','t','a','l','l',0};
4242
4243     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4244     if (rc != ERROR_SUCCESS)
4245         return ERROR_SUCCESS;
4246
4247     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallService, package);
4248     msiobj_release(&view->hdr);
4249
4250     return rc;
4251 }
4252
4253 /* converts arg1[~]arg2[~]arg3 to a list of ptrs to the strings */
4254 static LPCWSTR *msi_service_args_to_vector(LPCWSTR name, LPWSTR args, DWORD *numargs)
4255 {
4256     LPCWSTR *vector;
4257     LPWSTR p, q;
4258     DWORD sep_len;
4259
4260     static const WCHAR separator[] = {'[','~',']',0};
4261
4262     *numargs = 0;
4263     sep_len = sizeof(separator) / sizeof(WCHAR) - 1;
4264
4265     if (!args)
4266         return NULL;
4267
4268     vector = msi_alloc(sizeof(LPWSTR));
4269     if (!vector)
4270         return NULL;
4271
4272     p = args;
4273     do
4274     {
4275         (*numargs)++;
4276         vector[*numargs - 1] = p;
4277
4278         if ((q = strstrW(p, separator)))
4279         {
4280             *q = '\0';
4281
4282             vector = msi_realloc(vector, (*numargs + 1) * sizeof(LPWSTR));
4283             if (!vector)
4284                 return NULL;
4285
4286             p = q + sep_len;
4287         }
4288     } while (q);
4289
4290     return vector;
4291 }
4292
4293 static MSICOMPONENT *msi_find_component( MSIPACKAGE *package, LPCWSTR component )
4294 {
4295     MSICOMPONENT *comp;
4296
4297     LIST_FOR_EACH_ENTRY(comp, &package->components, MSICOMPONENT, entry)
4298     {
4299         if (!lstrcmpW(comp->Component, component))
4300             return comp;
4301     }
4302
4303     return NULL;
4304 }
4305
4306 static UINT ITERATE_StartService(MSIRECORD *rec, LPVOID param)
4307 {
4308     MSIPACKAGE *package = (MSIPACKAGE *)param;
4309     MSICOMPONENT *comp;
4310     SC_HANDLE scm, service = NULL;
4311     LPCWSTR name, *vector = NULL;
4312     LPWSTR args;
4313     DWORD event, numargs;
4314     UINT r = ERROR_FUNCTION_FAILED;
4315
4316     comp = msi_find_component(package, MSI_RecordGetString(rec, 6));
4317     if (!comp || comp->Action == INSTALLSTATE_UNKNOWN || comp->Action == INSTALLSTATE_ABSENT)
4318         return ERROR_SUCCESS;
4319
4320     name = MSI_RecordGetString(rec, 2);
4321     event = MSI_RecordGetInteger(rec, 3);
4322     args = strdupW(MSI_RecordGetString(rec, 4));
4323
4324     if (!(event & msidbServiceControlEventStart))
4325         return ERROR_SUCCESS;
4326
4327     scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
4328     if (!scm)
4329     {
4330         ERR("Failed to open the service control manager\n");
4331         goto done;
4332     }
4333
4334     service = OpenServiceW(scm, name, SERVICE_START);
4335     if (!service)
4336     {
4337         ERR("Failed to open service %s\n", debugstr_w(name));
4338         goto done;
4339     }
4340
4341     vector = msi_service_args_to_vector(name, args, &numargs);
4342
4343     if (!StartServiceW(service, numargs, vector))
4344     {
4345         ERR("Failed to start service %s\n", debugstr_w(name));
4346         goto done;
4347     }
4348
4349     r = ERROR_SUCCESS;
4350
4351 done:
4352     CloseServiceHandle(service);
4353     CloseServiceHandle(scm);
4354
4355     msi_free(args);
4356     msi_free(vector);
4357     return r;
4358 }
4359
4360 static UINT ACTION_StartServices( MSIPACKAGE *package )
4361 {
4362     UINT rc;
4363     MSIQUERY *view;
4364
4365     static const WCHAR query[] = {
4366         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4367         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4368
4369     rc = MSI_DatabaseOpenViewW(package->db, query, &view);
4370     if (rc != ERROR_SUCCESS)
4371         return ERROR_SUCCESS;
4372
4373     rc = MSI_IterateRecords(view, NULL, ITERATE_StartService, package);
4374     msiobj_release(&view->hdr);
4375
4376     return rc;
4377 }
4378
4379 static MSIFILE *msi_find_file( MSIPACKAGE *package, LPCWSTR filename )
4380 {
4381     MSIFILE *file;
4382
4383     LIST_FOR_EACH_ENTRY(file, &package->files, MSIFILE, entry)
4384     {
4385         if (!lstrcmpW(file->File, filename))
4386             return file;
4387     }
4388
4389     return NULL;
4390 }
4391
4392 static UINT ITERATE_InstallODBCDriver( MSIRECORD *rec, LPVOID param )
4393 {
4394     MSIPACKAGE *package = (MSIPACKAGE*)param;
4395     LPWSTR driver, driver_path, ptr;
4396     WCHAR outpath[MAX_PATH];
4397     MSIFILE *driver_file, *setup_file;
4398     LPCWSTR desc;
4399     DWORD len, usage;
4400     UINT r = ERROR_SUCCESS;
4401
4402     static const WCHAR driver_fmt[] = {
4403         'D','r','i','v','e','r','=','%','s',0};
4404     static const WCHAR setup_fmt[] = {
4405         'S','e','t','u','p','=','%','s',0};
4406     static const WCHAR usage_fmt[] = {
4407         'F','i','l','e','U','s','a','g','e','=','1',0};
4408
4409     desc = MSI_RecordGetString(rec, 3);
4410
4411     driver_file = msi_find_file(package, MSI_RecordGetString(rec, 4));
4412     setup_file = msi_find_file(package, MSI_RecordGetString(rec, 5));
4413
4414     if (!driver_file || !setup_file)
4415     {
4416         ERR("ODBC Driver entry not found!\n");
4417         return ERROR_FUNCTION_FAILED;
4418     }
4419
4420     len = lstrlenW(desc) + lstrlenW(driver_fmt) + lstrlenW(driver_file->FileName) +
4421           lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName) +
4422           lstrlenW(usage_fmt) + 1;
4423     driver = msi_alloc(len * sizeof(WCHAR));
4424     if (!driver)
4425         return ERROR_OUTOFMEMORY;
4426
4427     ptr = driver;
4428     lstrcpyW(ptr, desc);
4429     ptr += lstrlenW(ptr) + 1;
4430
4431     sprintfW(ptr, driver_fmt, driver_file->FileName);
4432     ptr += lstrlenW(ptr) + 1;
4433
4434     sprintfW(ptr, setup_fmt, setup_file->FileName);
4435     ptr += lstrlenW(ptr) + 1;
4436
4437     lstrcpyW(ptr, usage_fmt);
4438     ptr += lstrlenW(ptr) + 1;
4439     *ptr = '\0';
4440
4441     driver_path = strdupW(driver_file->TargetPath);
4442     ptr = strrchrW(driver_path, '\\');
4443     if (ptr) *ptr = '\0';
4444
4445     if (!SQLInstallDriverExW(driver, driver_path, outpath, MAX_PATH,
4446                              NULL, ODBC_INSTALL_COMPLETE, &usage))
4447     {
4448         ERR("Failed to install SQL driver!\n");
4449         r = ERROR_FUNCTION_FAILED;
4450     }
4451
4452     msi_free(driver);
4453     msi_free(driver_path);
4454
4455     return r;
4456 }
4457
4458 static UINT ITERATE_InstallODBCTranslator( MSIRECORD *rec, LPVOID param )
4459 {
4460     MSIPACKAGE *package = (MSIPACKAGE*)param;
4461     LPWSTR translator, translator_path, ptr;
4462     WCHAR outpath[MAX_PATH];
4463     MSIFILE *translator_file, *setup_file;
4464     LPCWSTR desc;
4465     DWORD len, usage;
4466     UINT r = ERROR_SUCCESS;
4467
4468     static const WCHAR translator_fmt[] = {
4469         'T','r','a','n','s','l','a','t','o','r','=','%','s',0};
4470     static const WCHAR setup_fmt[] = {
4471         'S','e','t','u','p','=','%','s',0};
4472
4473     desc = MSI_RecordGetString(rec, 3);
4474
4475     translator_file = msi_find_file(package, MSI_RecordGetString(rec, 4));
4476     setup_file = msi_find_file(package, MSI_RecordGetString(rec, 5));
4477
4478     if (!translator_file || !setup_file)
4479     {
4480         ERR("ODBC Translator entry not found!\n");
4481         return ERROR_FUNCTION_FAILED;
4482     }
4483
4484     len = lstrlenW(desc) + lstrlenW(translator_fmt) + lstrlenW(translator_file->FileName) +
4485           lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName) + 1;
4486     translator = msi_alloc(len * sizeof(WCHAR));
4487     if (!translator)
4488         return ERROR_OUTOFMEMORY;
4489
4490     ptr = translator;
4491     lstrcpyW(ptr, desc);
4492     ptr += lstrlenW(ptr) + 1;
4493
4494     sprintfW(ptr, translator_fmt, translator_file->FileName);
4495     ptr += lstrlenW(ptr) + 1;
4496
4497     sprintfW(ptr, setup_fmt, setup_file->FileName);
4498     ptr += lstrlenW(ptr) + 1;
4499     *ptr = '\0';
4500
4501     translator_path = strdupW(translator_file->TargetPath);
4502     ptr = strrchrW(translator_path, '\\');
4503     if (ptr) *ptr = '\0';
4504
4505     if (!SQLInstallTranslatorExW(translator, translator_path, outpath, MAX_PATH,
4506                                  NULL, ODBC_INSTALL_COMPLETE, &usage))
4507     {
4508         ERR("Failed to install SQL translator!\n");
4509         r = ERROR_FUNCTION_FAILED;
4510     }
4511
4512     msi_free(translator);
4513     msi_free(translator_path);
4514
4515     return r;
4516 }
4517
4518 static UINT ITERATE_InstallODBCDataSource( MSIRECORD *rec, LPVOID param )
4519 {
4520     LPWSTR attrs;
4521     LPCWSTR desc, driver;
4522     WORD request = ODBC_ADD_SYS_DSN;
4523     INT registration;
4524     DWORD len;
4525     UINT r = ERROR_SUCCESS;
4526
4527     static const WCHAR attrs_fmt[] = {
4528         'D','S','N','=','%','s',0 };
4529
4530     desc = MSI_RecordGetString(rec, 3);
4531     driver = MSI_RecordGetString(rec, 4);
4532     registration = MSI_RecordGetInteger(rec, 5);
4533
4534     if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_ADD_SYS_DSN;
4535     else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_ADD_DSN;
4536
4537     len = lstrlenW(attrs_fmt) + lstrlenW(desc) + 1 + 1;
4538     attrs = msi_alloc(len * sizeof(WCHAR));
4539     if (!attrs)
4540         return ERROR_OUTOFMEMORY;
4541
4542     sprintfW(attrs, attrs_fmt, desc);
4543     attrs[len - 1] = '\0';
4544
4545     if (!SQLConfigDataSourceW(NULL, request, driver, attrs))
4546     {
4547         ERR("Failed to install SQL data source!\n");
4548         r = ERROR_FUNCTION_FAILED;
4549     }
4550
4551     msi_free(attrs);
4552
4553     return r;
4554 }
4555
4556 static UINT ACTION_InstallODBC( MSIPACKAGE *package )
4557 {
4558     UINT rc;
4559     MSIQUERY *view;
4560
4561     static const WCHAR driver_query[] = {
4562         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4563         'O','D','B','C','D','r','i','v','e','r',0 };
4564
4565     static const WCHAR translator_query[] = {
4566         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4567         'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0 };
4568
4569     static const WCHAR source_query[] = {
4570         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4571         'O','D','B','C','D','a','t','a','S','o','u','r','c','e',0 };
4572
4573     rc = MSI_DatabaseOpenViewW(package->db, driver_query, &view);
4574     if (rc != ERROR_SUCCESS)
4575         return ERROR_SUCCESS;
4576
4577     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDriver, package);
4578     msiobj_release(&view->hdr);
4579
4580     rc = MSI_DatabaseOpenViewW(package->db, translator_query, &view);
4581     if (rc != ERROR_SUCCESS)
4582         return ERROR_SUCCESS;
4583
4584     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCTranslator, package);
4585     msiobj_release(&view->hdr);
4586
4587     rc = MSI_DatabaseOpenViewW(package->db, source_query, &view);
4588     if (rc != ERROR_SUCCESS)
4589         return ERROR_SUCCESS;
4590
4591     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDataSource, package);
4592     msiobj_release(&view->hdr);
4593
4594     return rc;
4595 }
4596
4597 #define ENV_ACT_SETALWAYS   0x1
4598 #define ENV_ACT_SETABSENT   0x2
4599 #define ENV_ACT_REMOVE      0x4
4600 #define ENV_ACT_REMOVEMATCH 0x8
4601
4602 #define ENV_MOD_MACHINE     0x20000000
4603 #define ENV_MOD_APPEND      0x40000000
4604 #define ENV_MOD_PREFIX      0x80000000
4605 #define ENV_MOD_MASK        0xC0000000
4606
4607 #define check_flag_combo(x, y) ((x) & ~(y)) == (y)
4608
4609 static LONG env_set_flags( LPCWSTR *name, LPWSTR *value, DWORD *flags )
4610 {
4611     LPCWSTR cptr = *name;
4612     LPWSTR ptr = *value;
4613
4614     static const WCHAR prefix[] = {'[','~',']',0};
4615
4616     *flags = 0;
4617     while (*cptr)
4618     {
4619         if (*cptr == '=')
4620             *flags |= ENV_ACT_SETALWAYS;
4621         else if (*cptr == '+')
4622             *flags |= ENV_ACT_SETABSENT;
4623         else if (*cptr == '-')
4624             *flags |= ENV_ACT_REMOVE;
4625         else if (*cptr == '!')
4626             *flags |= ENV_ACT_REMOVEMATCH;
4627         else if (*cptr == '*')
4628             *flags |= ENV_MOD_MACHINE;
4629         else
4630             break;
4631
4632         cptr++;
4633         (*name)++;
4634     }
4635
4636     if (!*cptr)
4637     {
4638         ERR("Missing environment variable\n");
4639         return ERROR_FUNCTION_FAILED;
4640     }
4641
4642     if (!strncmpW(ptr, prefix, lstrlenW(prefix)))
4643     {
4644         *flags |= ENV_MOD_PREFIX;
4645         *value += lstrlenW(prefix);
4646     }
4647     else
4648     {
4649         ptr += lstrlenW(ptr) - lstrlenW(prefix) - 1;
4650         if (!lstrcmpW(ptr, prefix))
4651         {
4652             *flags |= ENV_MOD_APPEND;
4653             *ptr = '\0';
4654         }
4655     }
4656
4657     if (!*flags ||
4658         check_flag_combo(*flags, ENV_ACT_SETALWAYS | ENV_ACT_SETABSENT) ||
4659         check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETABSENT) ||
4660         check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETALWAYS) ||
4661         check_flag_combo(*flags, ENV_ACT_SETABSENT | ENV_MOD_MASK))
4662     {
4663         ERR("Invalid flags: %08x\n", *flags);
4664         return ERROR_FUNCTION_FAILED;
4665     }
4666
4667     return ERROR_SUCCESS;
4668 }
4669
4670 static UINT ITERATE_WriteEnvironmentString( MSIRECORD *rec, LPVOID param )
4671 {
4672     MSIPACKAGE *package = param;
4673     LPCWSTR name, value, comp;
4674     LPWSTR data = NULL, newval = NULL;
4675     LPWSTR deformatted, ptr;
4676     DWORD flags, type, size;
4677     LONG res;
4678     HKEY env = NULL, root = HKEY_CURRENT_USER;
4679
4680     static const WCHAR environment[] =
4681         {'S','y','s','t','e','m','\\',
4682          'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
4683          'C','o','n','t','r','o','l','\\',
4684          'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
4685          'E','n','v','i','r','o','n','m','e','n','t',0};
4686     static const WCHAR semicolon[] = {';',0};
4687
4688     name = MSI_RecordGetString(rec, 2);
4689     value = MSI_RecordGetString(rec, 3);
4690     comp = MSI_RecordGetString(rec, 4);
4691
4692     deformat_string(package, value, &deformatted);
4693     if (!deformatted)
4694         return ERROR_OUTOFMEMORY;
4695
4696     res = env_set_flags(&name, &deformatted, &flags);
4697     if (res != ERROR_SUCCESS)
4698        goto done;
4699
4700     value = deformatted;
4701
4702     if (flags & ENV_MOD_MACHINE)
4703         root = HKEY_LOCAL_MACHINE;
4704
4705     res = RegOpenKeyExW(root, environment, 0, KEY_ALL_ACCESS, &env);
4706     if (res != ERROR_SUCCESS)
4707         goto done;
4708
4709     if (flags & ENV_ACT_REMOVE)
4710         FIXME("Not removing environment variable on uninstall!\n");
4711
4712     size = 0;
4713     res = RegQueryValueExW(env, name, NULL, &type, NULL, &size);
4714     if ((res != ERROR_SUCCESS && res != ERROR_FILE_NOT_FOUND) ||
4715         (res == ERROR_SUCCESS && type != REG_SZ))
4716         goto done;
4717
4718     if (res != ERROR_FILE_NOT_FOUND)
4719     {
4720         if (flags & ENV_ACT_SETABSENT)
4721         {
4722             res = ERROR_SUCCESS;
4723             goto done;
4724         }
4725
4726         data = msi_alloc(size);
4727         if (!data)
4728         {
4729             RegCloseKey(env);
4730             return ERROR_OUTOFMEMORY;
4731         }
4732
4733         res = RegQueryValueExW(env, name, NULL, &type, (LPVOID)data, &size);
4734         if (res != ERROR_SUCCESS)
4735             goto done;
4736
4737         if (flags & ENV_ACT_REMOVEMATCH && (!value || !lstrcmpW(data, value)))
4738         {
4739             res = RegDeleteKeyW(env, name);
4740             goto done;
4741         }
4742
4743         size =  (lstrlenW(value) + 1 + size) * sizeof(WCHAR);
4744         newval =  msi_alloc(size);
4745         ptr = newval;
4746         if (!newval)
4747         {
4748             res = ERROR_OUTOFMEMORY;
4749             goto done;
4750         }
4751
4752         if (!(flags & ENV_MOD_MASK))
4753             lstrcpyW(newval, value);
4754         else
4755         {
4756             if (flags & ENV_MOD_PREFIX)
4757             {
4758                 lstrcpyW(newval, value);
4759                 lstrcatW(newval, semicolon);
4760                 ptr = newval + lstrlenW(value) + 1;
4761             }
4762
4763             lstrcpyW(ptr, data);
4764
4765             if (flags & ENV_MOD_APPEND)
4766             {
4767                 lstrcatW(newval, semicolon);
4768                 lstrcatW(newval, value);
4769             }
4770         }
4771     }
4772     else
4773     {
4774         size = (lstrlenW(value) + 1) * sizeof(WCHAR);
4775         newval = msi_alloc(size);
4776         if (!newval)
4777         {
4778             res = ERROR_OUTOFMEMORY;
4779             goto done;
4780         }
4781
4782         lstrcpyW(newval, value);
4783     }
4784
4785     TRACE("setting %s to %s\n", debugstr_w(name), debugstr_w(newval));
4786     res = RegSetValueExW(env, name, 0, type, (LPVOID)newval, size);
4787
4788 done:
4789     if (env) RegCloseKey(env);
4790     msi_free(deformatted);
4791     msi_free(data);
4792     msi_free(newval);
4793     return res;
4794 }
4795
4796 static UINT ACTION_WriteEnvironmentStrings( MSIPACKAGE *package )
4797 {
4798     UINT rc;
4799     MSIQUERY * view;
4800     static const WCHAR ExecSeqQuery[] =
4801         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4802          '`','E','n','v','i','r','o','n','m','e','n','t','`',0};
4803     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4804     if (rc != ERROR_SUCCESS)
4805         return ERROR_SUCCESS;
4806
4807     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteEnvironmentString, package);
4808     msiobj_release(&view->hdr);
4809
4810     return rc;
4811 }
4812
4813 static UINT msi_unimplemented_action_stub( MSIPACKAGE *package,
4814                                            LPCSTR action, LPCWSTR table )
4815 {
4816     static const WCHAR query[] = {
4817         'S','E','L','E','C','T',' ','*',' ',
4818         'F','R','O','M',' ','`','%','s','`',0 };
4819     MSIQUERY *view = NULL;
4820     DWORD count = 0;
4821     UINT r;
4822
4823     r = MSI_OpenQuery( package->db, &view, query, table );
4824     if (r == ERROR_SUCCESS)
4825     {
4826         r = MSI_IterateRecords(view, &count, NULL, package);
4827         msiobj_release(&view->hdr);
4828     }
4829
4830     if (count)
4831         FIXME("%s -> %u ignored %s table values\n",
4832               action, count, debugstr_w(table));
4833
4834     return ERROR_SUCCESS;
4835 }
4836
4837 static UINT ACTION_AllocateRegistrySpace( MSIPACKAGE *package )
4838 {
4839     TRACE("%p\n", package);
4840     return ERROR_SUCCESS;
4841 }
4842
4843 static UINT ACTION_RemoveIniValues( MSIPACKAGE *package )
4844 {
4845     static const WCHAR table[] =
4846          {'R','e','m','o','v','e','I','n','i','F','i','l','e',0 };
4847     return msi_unimplemented_action_stub( package, "RemoveIniValues", table );
4848 }
4849
4850 static UINT ACTION_MoveFiles( MSIPACKAGE *package )
4851 {
4852     static const WCHAR table[] = { 'M','o','v','e','F','i','l','e',0 };
4853     return msi_unimplemented_action_stub( package, "MoveFiles", table );
4854 }
4855
4856 static UINT ACTION_PatchFiles( MSIPACKAGE *package )
4857 {
4858     static const WCHAR table[] = { 'P','a','t','c','h',0 };
4859     return msi_unimplemented_action_stub( package, "PatchFiles", table );
4860 }
4861
4862 static UINT ACTION_BindImage( MSIPACKAGE *package )
4863 {
4864     static const WCHAR table[] = { 'B','i','n','d','I','m','a','g','e',0 };
4865     return msi_unimplemented_action_stub( package, "BindImage", table );
4866 }
4867
4868 static UINT ACTION_IsolateComponents( MSIPACKAGE *package )
4869 {
4870     static const WCHAR table[] = {
4871         'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t',0 };
4872     return msi_unimplemented_action_stub( package, "IsolateComponents", table );
4873 }
4874
4875 static UINT ACTION_MigrateFeatureStates( MSIPACKAGE *package )
4876 {
4877     static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
4878     return msi_unimplemented_action_stub( package, "MigrateFeatureStates", table );
4879 }
4880
4881 static UINT ACTION_SelfUnregModules( MSIPACKAGE *package )
4882 {
4883     static const WCHAR table[] = { 'S','e','l','f','R','e','g',0 };
4884     return msi_unimplemented_action_stub( package, "SelfUnregModules", table );
4885 }
4886
4887 static UINT ACTION_StopServices( MSIPACKAGE *package )
4888 {
4889     static const WCHAR table[] = {
4890         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4891     return msi_unimplemented_action_stub( package, "StopServices", table );
4892 }
4893
4894 static UINT ACTION_DeleteServices( MSIPACKAGE *package )
4895 {
4896     static const WCHAR table[] = {
4897         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4898     return msi_unimplemented_action_stub( package, "DeleteServices", table );
4899 }
4900 static UINT ACTION_ValidateProductID( MSIPACKAGE *package )
4901 {
4902         static const WCHAR table[] = {
4903                 'P','r','o','d','u','c','t','I','D',0 };
4904         return msi_unimplemented_action_stub( package, "ValidateProductID", table );
4905 }
4906
4907 static UINT ACTION_RemoveEnvironmentStrings( MSIPACKAGE *package )
4908 {
4909     static const WCHAR table[] = {
4910         'E','n','v','i','r','o','n','m','e','n','t',0 };
4911     return msi_unimplemented_action_stub( package, "RemoveEnvironmentStrings", table );
4912 }
4913
4914 static UINT ACTION_MsiPublishAssemblies( MSIPACKAGE *package )
4915 {
4916     static const WCHAR table[] = {
4917         'M','s','i','A','s','s','e','m','b','l','y',0 };
4918     return msi_unimplemented_action_stub( package, "MsiPublishAssemblies", table );
4919 }
4920
4921 static UINT ACTION_MsiUnpublishAssemblies( MSIPACKAGE *package )
4922 {
4923     static const WCHAR table[] = {
4924         'M','s','i','A','s','s','e','m','b','l','y',0 };
4925     return msi_unimplemented_action_stub( package, "MsiUnpublishAssemblies", table );
4926 }
4927
4928 static UINT ACTION_UnregisterFonts( MSIPACKAGE *package )
4929 {
4930     static const WCHAR table[] = { 'F','o','n','t',0 };
4931     return msi_unimplemented_action_stub( package, "UnregisterFonts", table );
4932 }
4933
4934 static UINT ACTION_CCPSearch( MSIPACKAGE *package )
4935 {
4936     static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
4937     return msi_unimplemented_action_stub( package, "CCPSearch", table );
4938 }
4939
4940 static UINT ACTION_RMCCPSearch( MSIPACKAGE *package )
4941 {
4942     static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
4943     return msi_unimplemented_action_stub( package, "RMCCPSearch", table );
4944 }
4945
4946 static UINT ACTION_RegisterComPlus( MSIPACKAGE *package )
4947 {
4948     static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
4949     return msi_unimplemented_action_stub( package, "RegisterComPlus", table );
4950 }
4951
4952 static UINT ACTION_UnregisterComPlus( MSIPACKAGE *package )
4953 {
4954     static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
4955     return msi_unimplemented_action_stub( package, "UnregisterComPlus", table );
4956 }
4957
4958 static UINT ACTION_InstallSFPCatalogFile( MSIPACKAGE *package )
4959 {
4960     static const WCHAR table[] = { 'S','F','P','C','a','t','a','l','o','g',0 };
4961     return msi_unimplemented_action_stub( package, "InstallSFPCatalogFile", table );
4962 }
4963
4964 static UINT ACTION_RemoveDuplicateFiles( MSIPACKAGE *package )
4965 {
4966     static const WCHAR table[] = { 'D','u','p','l','i','c','a','t','e','F','i','l','e',0 };
4967     return msi_unimplemented_action_stub( package, "RemoveDuplicateFiles", table );
4968 }
4969
4970 static UINT ACTION_RemoveExistingProducts( MSIPACKAGE *package )
4971 {
4972     static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
4973     return msi_unimplemented_action_stub( package, "RemoveExistingProducts", table );
4974 }
4975
4976 static UINT ACTION_RemoveFolders( MSIPACKAGE *package )
4977 {
4978     static const WCHAR table[] = { 'C','r','e','a','t','e','F','o','l','d','e','r',0 };
4979     return msi_unimplemented_action_stub( package, "RemoveFolders", table );
4980 }
4981
4982 static UINT ACTION_RemoveODBC( MSIPACKAGE *package )
4983 {
4984     static const WCHAR table[] = { 'O','D','B','C','D','r','i','v','e','r',0 };
4985     return msi_unimplemented_action_stub( package, "RemoveODBC", table );
4986 }
4987
4988 static UINT ACTION_RemoveRegistryValues( MSIPACKAGE *package )
4989 {
4990     static const WCHAR table[] = { 'R','e','m','o','v','e','R','e','g','i','s','t','r','y',0 };
4991     return msi_unimplemented_action_stub( package, "RemoveRegistryValues", table );
4992 }
4993
4994 static UINT ACTION_RemoveShortcuts( MSIPACKAGE *package )
4995 {
4996     static const WCHAR table[] = { 'S','h','o','r','t','c','u','t',0 };
4997     return msi_unimplemented_action_stub( package, "RemoveShortcuts", table );
4998 }
4999
5000 static UINT ACTION_UnpublishComponents( MSIPACKAGE *package )
5001 {
5002     static const WCHAR table[] = { 'P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t',0 };
5003     return msi_unimplemented_action_stub( package, "UnpublishComponents", table );
5004 }
5005
5006 static UINT ACTION_UnpublishFeatures( MSIPACKAGE *package )
5007 {
5008     static const WCHAR table[] = { 'F','e','a','t','u','r','e','C','o','m','p','o','n','e','n','t','s',0 };
5009     return msi_unimplemented_action_stub( package, "UnpublishFeatures", table );
5010 }
5011
5012 static UINT ACTION_UnregisterClassInfo( MSIPACKAGE *package )
5013 {
5014     static const WCHAR table[] = { 'A','p','p','I','d',0 };
5015     return msi_unimplemented_action_stub( package, "UnregisterClassInfo", table );
5016 }
5017
5018 static UINT ACTION_UnregisterExtensionInfo( MSIPACKAGE *package )
5019 {
5020     static const WCHAR table[] = { 'E','x','t','e','n','s','i','o','n',0 };
5021     return msi_unimplemented_action_stub( package, "UnregisterExtensionInfo", table );
5022 }
5023
5024 static UINT ACTION_UnregisterMIMEInfo( MSIPACKAGE *package )
5025 {
5026     static const WCHAR table[] = { 'M','I','M','E',0 };
5027     return msi_unimplemented_action_stub( package, "UnregisterMIMEInfo", table );
5028 }
5029
5030 static UINT ACTION_UnregisterProgIdInfo( MSIPACKAGE *package )
5031 {
5032     static const WCHAR table[] = { 'P','r','o','g','I','d',0 };
5033     return msi_unimplemented_action_stub( package, "UnregisterProgIdInfo", table );
5034 }
5035
5036 static UINT ACTION_UnregisterTypeLibraries( MSIPACKAGE *package )
5037 {
5038     static const WCHAR table[] = { 'T','y','p','e','L','i','b',0 };
5039     return msi_unimplemented_action_stub( package, "UnregisterTypeLibraries", table );
5040 }
5041
5042 static const struct _actions StandardActions[] = {
5043     { szAllocateRegistrySpace, ACTION_AllocateRegistrySpace },
5044     { szAppSearch, ACTION_AppSearch },
5045     { szBindImage, ACTION_BindImage },
5046     { szCCPSearch, ACTION_CCPSearch },
5047     { szCostFinalize, ACTION_CostFinalize },
5048     { szCostInitialize, ACTION_CostInitialize },
5049     { szCreateFolders, ACTION_CreateFolders },
5050     { szCreateShortcuts, ACTION_CreateShortcuts },
5051     { szDeleteServices, ACTION_DeleteServices },
5052     { szDisableRollback, NULL },
5053     { szDuplicateFiles, ACTION_DuplicateFiles },
5054     { szExecuteAction, ACTION_ExecuteAction },
5055     { szFileCost, ACTION_FileCost },
5056     { szFindRelatedProducts, ACTION_FindRelatedProducts },
5057     { szForceReboot, ACTION_ForceReboot },
5058     { szInstallAdminPackage, NULL },
5059     { szInstallExecute, ACTION_InstallExecute },
5060     { szInstallExecuteAgain, ACTION_InstallExecute },
5061     { szInstallFiles, ACTION_InstallFiles},
5062     { szInstallFinalize, ACTION_InstallFinalize },
5063     { szInstallInitialize, ACTION_InstallInitialize },
5064     { szInstallSFPCatalogFile, ACTION_InstallSFPCatalogFile },
5065     { szInstallValidate, ACTION_InstallValidate },
5066     { szIsolateComponents, ACTION_IsolateComponents },
5067     { szLaunchConditions, ACTION_LaunchConditions },
5068     { szMigrateFeatureStates, ACTION_MigrateFeatureStates },
5069     { szMoveFiles, ACTION_MoveFiles },
5070     { szMsiPublishAssemblies, ACTION_MsiPublishAssemblies },
5071     { szMsiUnpublishAssemblies, ACTION_MsiUnpublishAssemblies },
5072     { szInstallODBC, ACTION_InstallODBC },
5073     { szInstallServices, ACTION_InstallServices },
5074     { szPatchFiles, ACTION_PatchFiles },
5075     { szProcessComponents, ACTION_ProcessComponents },
5076     { szPublishComponents, ACTION_PublishComponents },
5077     { szPublishFeatures, ACTION_PublishFeatures },
5078     { szPublishProduct, ACTION_PublishProduct },
5079     { szRegisterClassInfo, ACTION_RegisterClassInfo },
5080     { szRegisterComPlus, ACTION_RegisterComPlus},
5081     { szRegisterExtensionInfo, ACTION_RegisterExtensionInfo },
5082     { szRegisterFonts, ACTION_RegisterFonts },
5083     { szRegisterMIMEInfo, ACTION_RegisterMIMEInfo },
5084     { szRegisterProduct, ACTION_RegisterProduct },
5085     { szRegisterProgIdInfo, ACTION_RegisterProgIdInfo },
5086     { szRegisterTypeLibraries, ACTION_RegisterTypeLibraries },
5087     { szRegisterUser, ACTION_RegisterUser },
5088     { szRemoveDuplicateFiles, ACTION_RemoveDuplicateFiles },
5089     { szRemoveEnvironmentStrings, ACTION_RemoveEnvironmentStrings },
5090     { szRemoveExistingProducts, ACTION_RemoveExistingProducts },
5091     { szRemoveFiles, ACTION_RemoveFiles },
5092     { szRemoveFolders, ACTION_RemoveFolders },
5093     { szRemoveIniValues, ACTION_RemoveIniValues },
5094     { szRemoveODBC, ACTION_RemoveODBC },
5095     { szRemoveRegistryValues, ACTION_RemoveRegistryValues },
5096     { szRemoveShortcuts, ACTION_RemoveShortcuts },
5097     { szResolveSource, ACTION_ResolveSource },
5098     { szRMCCPSearch, ACTION_RMCCPSearch },
5099     { szScheduleReboot, NULL },
5100     { szSelfRegModules, ACTION_SelfRegModules },
5101     { szSelfUnregModules, ACTION_SelfUnregModules },
5102     { szSetODBCFolders, NULL },
5103     { szStartServices, ACTION_StartServices },
5104     { szStopServices, ACTION_StopServices },
5105     { szUnpublishComponents, ACTION_UnpublishComponents },
5106     { szUnpublishFeatures, ACTION_UnpublishFeatures },
5107     { szUnregisterClassInfo, ACTION_UnregisterClassInfo },
5108     { szUnregisterComPlus, ACTION_UnregisterComPlus },
5109     { szUnregisterExtensionInfo, ACTION_UnregisterExtensionInfo },
5110     { szUnregisterFonts, ACTION_UnregisterFonts },
5111     { szUnregisterMIMEInfo, ACTION_UnregisterMIMEInfo },
5112     { szUnregisterProgIdInfo, ACTION_UnregisterProgIdInfo },
5113     { szUnregisterTypeLibraries, ACTION_UnregisterTypeLibraries },
5114     { szValidateProductID, ACTION_ValidateProductID },
5115     { szWriteEnvironmentStrings, ACTION_WriteEnvironmentStrings },
5116     { szWriteIniValues, ACTION_WriteIniValues },
5117     { szWriteRegistryValues, ACTION_WriteRegistryValues },
5118     { NULL, NULL },
5119 };