git.oblomov.eu Git - wine/blob - dlls/msi/action.c

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