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

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