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( 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( 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         ERR("Unfound Component %s\n",debugstr_w(component));
1461
1462     file->FileName = msi_dup_record_field( row, 3 );
1463     reduce_to_longfilename( file->FileName );
1464
1465     file->ShortName = msi_dup_record_field( row, 3 );
1466     file->LongName = strdupW( folder_split_path(file->ShortName, '|'));
1467
1468     file->FileSize = MSI_RecordGetInteger( row, 4 );
1469     file->Version = msi_dup_record_field( row, 5 );
1470     file->Language = msi_dup_record_field( row, 6 );
1471     file->Attributes = MSI_RecordGetInteger( row, 7 );
1472     file->Sequence = MSI_RecordGetInteger( row, 8 );
1473
1474     file->state = msifs_invalid;
1475
1476     /* if the compressed bits are not set in the file attributes,
1477      * then read the information from the package word count property
1478      */
1479     if (file->Attributes & msidbFileAttributesCompressed)
1480     {
1481         file->IsCompressed = TRUE;
1482     }
1483     else if (file->Attributes & msidbFileAttributesNoncompressed)
1484     {
1485         file->IsCompressed = FALSE;
1486     }
1487     else
1488     {
1489         file->IsCompressed = package->WordCount & MSIWORDCOUNT_COMPRESSED;
1490     }
1491
1492     if (!file->IsCompressed)
1493     {
1494         LPWSTR p, path;
1495
1496         p = resolve_folder(package, file->Component->Directory,
1497                            TRUE, FALSE, TRUE, NULL);
1498         path = build_directory_name(2, p, file->ShortName);
1499
1500         if (file->LongName &&
1501             GetFileAttributesW(path) == INVALID_FILE_ATTRIBUTES)
1502         {
1503             msi_free(path);
1504             path = build_directory_name(2, p, file->LongName);
1505         }
1506
1507         file->SourcePath = path;
1508         msi_free(p);
1509     }
1510
1511     load_file_hash(package, file);
1512
1513     TRACE("File Loaded (%s)\n",debugstr_w(file->File));
1514
1515     list_add_tail( &package->files, &file->entry );
1516
1517     return ERROR_SUCCESS;
1518 }
1519
1520 static UINT load_all_files(MSIPACKAGE *package)
1521 {
1522     MSIQUERY * view;
1523     UINT rc;
1524     static const WCHAR Query[] =
1525         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
1526          '`','F','i','l','e','`',' ', 'O','R','D','E','R',' ','B','Y',' ',
1527          '`','S','e','q','u','e','n','c','e','`', 0};
1528
1529     if (!list_empty(&package->files))
1530         return ERROR_SUCCESS;
1531
1532     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
1533     if (rc != ERROR_SUCCESS)
1534         return ERROR_SUCCESS;
1535
1536     rc = MSI_IterateRecords(view, NULL, load_file, package);
1537     msiobj_release(&view->hdr);
1538
1539     return ERROR_SUCCESS;
1540 }
1541
1542 static UINT load_folder( MSIRECORD *row, LPVOID param )
1543 {
1544     MSIPACKAGE *package = param;
1545     static const WCHAR szDot[] = { '.',0 };
1546     static WCHAR szEmpty[] = { 0 };
1547     LPWSTR p, tgt_short, tgt_long, src_short, src_long;
1548     MSIFOLDER *folder;
1549
1550     folder = msi_alloc_zero( sizeof (MSIFOLDER) );
1551     if (!folder)
1552         return ERROR_NOT_ENOUGH_MEMORY;
1553
1554     folder->Directory = msi_dup_record_field( row, 1 );
1555
1556     TRACE("%s\n", debugstr_w(folder->Directory));
1557
1558     p = msi_dup_record_field(row, 3);
1559
1560     /* split src and target dir */
1561     tgt_short = p;
1562     src_short = folder_split_path( p, ':' );
1563
1564     /* split the long and short paths */
1565     tgt_long = folder_split_path( tgt_short, '|' );
1566     src_long = folder_split_path( src_short, '|' );
1567
1568     /* check for no-op dirs */
1569     if (!lstrcmpW(szDot, tgt_short))
1570         tgt_short = szEmpty;
1571     if (!lstrcmpW(szDot, src_short))
1572         src_short = szEmpty;
1573
1574     if (!tgt_long)
1575         tgt_long = tgt_short;
1576
1577     if (!src_short) {
1578         src_short = tgt_short;
1579         src_long = tgt_long;
1580     }
1581
1582     if (!src_long)
1583         src_long = src_short;
1584
1585     /* FIXME: use the target short path too */
1586     folder->TargetDefault = strdupW(tgt_long);
1587     folder->SourceShortPath = strdupW(src_short);
1588     folder->SourceLongPath = strdupW(src_long);
1589     msi_free(p);
1590
1591     TRACE("TargetDefault = %s\n",debugstr_w( folder->TargetDefault ));
1592     TRACE("SourceLong = %s\n", debugstr_w( folder->SourceLongPath ));
1593     TRACE("SourceShort = %s\n", debugstr_w( folder->SourceShortPath ));
1594
1595     folder->Parent = msi_dup_record_field( row, 2 );
1596
1597     folder->Property = msi_dup_property( package, folder->Directory );
1598
1599     list_add_tail( &package->folders, &folder->entry );
1600
1601     TRACE("returning %p\n", folder);
1602
1603     return ERROR_SUCCESS;
1604 }
1605
1606 static UINT load_all_folders( MSIPACKAGE *package )
1607 {
1608     static const WCHAR query[] = {
1609         'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
1610          '`','D','i','r','e','c','t','o','r','y','`',0 };
1611     MSIQUERY *view;
1612     UINT r;
1613
1614     if (!list_empty(&package->folders))
1615         return ERROR_SUCCESS;
1616
1617     r = MSI_DatabaseOpenViewW( package->db, query, &view );
1618     if (r != ERROR_SUCCESS)
1619         return r;
1620
1621     r = MSI_IterateRecords(view, NULL, load_folder, package);
1622     msiobj_release(&view->hdr);
1623     return r;
1624 }
1625
1626 /*
1627  * I am not doing any of the costing functionality yet.
1628  * Mostly looking at doing the Component and Feature loading
1629  *
1630  * The native MSI does A LOT of modification to tables here. Mostly adding
1631  * a lot of temporary columns to the Feature and Component tables.
1632  *
1633  *    note: Native msi also tracks the short filename. But I am only going to
1634  *          track the long ones.  Also looking at this directory table
1635  *          it appears that the directory table does not get the parents
1636  *          resolved base on property only based on their entries in the
1637  *          directory table.
1638  */
1639 static UINT ACTION_CostInitialize(MSIPACKAGE *package)
1640 {
1641     static const WCHAR szCosting[] =
1642         {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
1643     static const WCHAR szZero[] = { '0', 0 };
1644
1645     MSI_SetPropertyW(package, szCosting, szZero);
1646     MSI_SetPropertyW(package, cszRootDrive, c_colon);
1647
1648     load_all_folders( package );
1649     load_all_components( package );
1650     load_all_features( package );
1651     load_all_files( package );
1652
1653     return ERROR_SUCCESS;
1654 }
1655
1656 static UINT execute_script(MSIPACKAGE *package, UINT script )
1657 {
1658     UINT i;
1659     UINT rc = ERROR_SUCCESS;
1660
1661     TRACE("Executing Script %i\n",script);
1662
1663     if (!package->script)
1664     {
1665         ERR("no script!\n");
1666         return ERROR_FUNCTION_FAILED;
1667     }
1668
1669     for (i = 0; i < package->script->ActionCount[script]; i++)
1670     {
1671         LPWSTR action;
1672         action = package->script->Actions[script][i];
1673         ui_actionstart(package, action);
1674         TRACE("Executing Action (%s)\n",debugstr_w(action));
1675         rc = ACTION_PerformAction(package, action, script, TRUE);
1676         if (rc != ERROR_SUCCESS)
1677             break;
1678     }
1679     msi_free_action_script(package, script);
1680     return rc;
1681 }
1682
1683 static UINT ACTION_FileCost(MSIPACKAGE *package)
1684 {
1685     return ERROR_SUCCESS;
1686 }
1687
1688 static void ACTION_GetComponentInstallStates(MSIPACKAGE *package)
1689 {
1690     MSICOMPONENT *comp;
1691
1692     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1693     {
1694         INSTALLSTATE res;
1695
1696         if (!comp->ComponentId)
1697             continue;
1698
1699         res = MsiGetComponentPathW( package->ProductCode,
1700                                     comp->ComponentId, NULL, NULL);
1701         if (res < 0)
1702             res = INSTALLSTATE_ABSENT;
1703         comp->Installed = res;
1704     }
1705 }
1706
1707 /* scan for and update current install states */
1708 static void ACTION_UpdateFeatureInstallStates(MSIPACKAGE *package)
1709 {
1710     MSICOMPONENT *comp;
1711     MSIFEATURE *feature;
1712
1713     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1714     {
1715         ComponentList *cl;
1716         INSTALLSTATE res = INSTALLSTATE_ABSENT;
1717
1718         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1719         {
1720             comp= cl->component;
1721
1722             if (!comp->ComponentId)
1723             {
1724                 res = INSTALLSTATE_ABSENT;
1725                 break;
1726             }
1727
1728             if (res == INSTALLSTATE_ABSENT)
1729                 res = comp->Installed;
1730             else
1731             {
1732                 if (res == comp->Installed)
1733                     continue;
1734
1735                 if (res != INSTALLSTATE_DEFAULT && res != INSTALLSTATE_LOCAL &&
1736                     res != INSTALLSTATE_SOURCE)
1737                 {
1738                     res = INSTALLSTATE_INCOMPLETE;
1739                 }
1740             }
1741         }
1742         feature->Installed = res;
1743     }
1744 }
1745
1746 static BOOL process_state_property (MSIPACKAGE* package, LPCWSTR property,
1747                                     INSTALLSTATE state)
1748 {
1749     static const WCHAR all[]={'A','L','L',0};
1750     LPWSTR override;
1751     MSIFEATURE *feature;
1752
1753     override = msi_dup_property( package, property );
1754     if (!override)
1755         return FALSE;
1756
1757     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1758     {
1759         if (strcmpiW(override,all)==0)
1760             msi_feature_set_state( feature, state );
1761         else
1762         {
1763             LPWSTR ptr = override;
1764             LPWSTR ptr2 = strchrW(override,',');
1765
1766             while (ptr)
1767             {
1768                 if ((ptr2 && strncmpW(ptr,feature->Feature, ptr2-ptr)==0)
1769                     || (!ptr2 && strcmpW(ptr,feature->Feature)==0))
1770                 {
1771                     msi_feature_set_state( feature, state );
1772                     break;
1773                 }
1774                 if (ptr2)
1775                 {
1776                     ptr=ptr2+1;
1777                     ptr2 = strchrW(ptr,',');
1778                 }
1779                 else
1780                     break;
1781             }
1782         }
1783     }
1784     msi_free(override);
1785
1786     return TRUE;
1787 }
1788
1789 UINT MSI_SetFeatureStates(MSIPACKAGE *package)
1790 {
1791     int install_level;
1792     static const WCHAR szlevel[] =
1793         {'I','N','S','T','A','L','L','L','E','V','E','L',0};
1794     static const WCHAR szAddLocal[] =
1795         {'A','D','D','L','O','C','A','L',0};
1796     static const WCHAR szAddSource[] =
1797         {'A','D','D','S','O','U','R','C','E',0};
1798     static const WCHAR szRemove[] =
1799         {'R','E','M','O','V','E',0};
1800     static const WCHAR szReinstall[] =
1801         {'R','E','I','N','S','T','A','L','L',0};
1802     BOOL override = FALSE;
1803     MSICOMPONENT* component;
1804     MSIFEATURE *feature;
1805
1806
1807     /* I do not know if this is where it should happen.. but */
1808
1809     TRACE("Checking Install Level\n");
1810
1811     install_level = msi_get_property_int( package, szlevel, 1 );
1812
1813     /* ok here is the _real_ rub
1814      * all these activation/deactivation things happen in order and things
1815      * later on the list override things earlier on the list.
1816      * 1) INSTALLLEVEL processing
1817      * 2) ADDLOCAL
1818      * 3) REMOVE
1819      * 4) ADDSOURCE
1820      * 5) ADDDEFAULT
1821      * 6) REINSTALL
1822      * 7) COMPADDLOCAL
1823      * 8) COMPADDSOURCE
1824      * 9) FILEADDLOCAL
1825      * 10) FILEADDSOURCE
1826      * 11) FILEADDDEFAULT
1827      *
1828      * I am still ignoring a lot of these. But that is ok for now, ADDLOCAL and
1829      * REMOVE are the big ones, since we don't handle administrative installs
1830      * yet anyway.
1831      */
1832     override |= process_state_property(package,szAddLocal,INSTALLSTATE_LOCAL);
1833     override |= process_state_property(package,szRemove,INSTALLSTATE_ABSENT);
1834     override |= process_state_property(package,szAddSource,INSTALLSTATE_SOURCE);
1835     override |= process_state_property(package,szReinstall,INSTALLSTATE_LOCAL);
1836
1837     if (!override)
1838     {
1839         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1840         {
1841             BOOL feature_state = ((feature->Level > 0) &&
1842                              (feature->Level <= install_level));
1843
1844             if ((feature_state) && (feature->Action == INSTALLSTATE_UNKNOWN))
1845             {
1846                 if (feature->Attributes & msidbFeatureAttributesFavorSource)
1847                     msi_feature_set_state( feature, INSTALLSTATE_SOURCE );
1848                 else if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1849                     msi_feature_set_state( feature, INSTALLSTATE_ADVERTISED );
1850                 else
1851                     msi_feature_set_state( feature, INSTALLSTATE_LOCAL );
1852             }
1853         }
1854
1855         /* disable child features of unselected parent features */
1856         LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1857         {
1858             FeatureList *fl;
1859
1860             if (feature->Level > 0 && feature->Level <= install_level)
1861                 continue;
1862
1863             LIST_FOR_EACH_ENTRY( fl, &feature->Children, FeatureList, entry )
1864                 msi_feature_set_state( fl->feature, INSTALLSTATE_UNKNOWN );
1865         }
1866     }
1867     else
1868     {
1869         /* set the Preselected Property */
1870         static const WCHAR szPreselected[] = {'P','r','e','s','e','l','e','c','t','e','d',0};
1871         static const WCHAR szOne[] = { '1', 0 };
1872
1873         MSI_SetPropertyW(package,szPreselected,szOne);
1874     }
1875
1876     /*
1877      * now we want to enable or disable components base on feature
1878      */
1879
1880     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1881     {
1882         ComponentList *cl;
1883
1884         TRACE("Examining Feature %s (Level %i, Installed %i, Action %i)\n",
1885               debugstr_w(feature->Feature), feature->Level, feature->Installed, feature->Action);
1886
1887         if (!feature->Level)
1888             continue;
1889
1890         /* features with components that have compressed files are made local */
1891         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1892         {
1893             if (cl->component->Enabled &&
1894                 cl->component->ForceLocalState &&
1895                 feature->Action == INSTALLSTATE_SOURCE)
1896             {
1897                 msi_feature_set_state( feature, INSTALLSTATE_LOCAL );
1898                 break;
1899             }
1900         }
1901
1902         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1903         {
1904             component = cl->component;
1905
1906             if (!component->Enabled)
1907                 continue;
1908
1909             switch (feature->Action)
1910             {
1911             case INSTALLSTATE_ABSENT:
1912                 component->anyAbsent = 1;
1913                 break;
1914             case INSTALLSTATE_ADVERTISED:
1915                 component->hasAdvertiseFeature = 1;
1916                 break;
1917             case INSTALLSTATE_SOURCE:
1918                 component->hasSourceFeature = 1;
1919                 break;
1920             case INSTALLSTATE_LOCAL:
1921                 component->hasLocalFeature = 1;
1922                 break;
1923             case INSTALLSTATE_DEFAULT:
1924                 if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1925                     component->hasAdvertiseFeature = 1;
1926                 else if (feature->Attributes & msidbFeatureAttributesFavorSource)
1927                     component->hasSourceFeature = 1;
1928                 else
1929                     component->hasLocalFeature = 1;
1930                 break;
1931             default:
1932                 break;
1933             }
1934         }
1935     }
1936
1937     LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1938     {
1939         /* if the component isn't enabled, leave it alone */
1940         if (!component->Enabled)
1941             continue;
1942
1943         /* check if it's local or source */
1944         if (!(component->Attributes & msidbComponentAttributesOptional) &&
1945              (component->hasLocalFeature || component->hasSourceFeature))
1946         {
1947             if ((component->Attributes & msidbComponentAttributesSourceOnly) &&
1948                  !component->ForceLocalState)
1949                 msi_component_set_state( component, INSTALLSTATE_SOURCE );
1950             else
1951                 msi_component_set_state( component, INSTALLSTATE_LOCAL );
1952             continue;
1953         }
1954
1955         /* if any feature is local, the component must be local too */
1956         if (component->hasLocalFeature)
1957         {
1958             msi_component_set_state( component, INSTALLSTATE_LOCAL );
1959             continue;
1960         }
1961
1962         if (component->hasSourceFeature)
1963         {
1964             msi_component_set_state( component, INSTALLSTATE_SOURCE );
1965             continue;
1966         }
1967
1968         if (component->hasAdvertiseFeature)
1969         {
1970             msi_component_set_state( component, INSTALLSTATE_ADVERTISED );
1971             continue;
1972         }
1973
1974         TRACE("nobody wants component %s\n", debugstr_w(component->Component));
1975         if (component->anyAbsent)
1976             msi_component_set_state(component, INSTALLSTATE_ABSENT);
1977     }
1978
1979     LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1980     {
1981         if (component->Action == INSTALLSTATE_DEFAULT)
1982         {
1983             TRACE("%s was default, setting to local\n", debugstr_w(component->Component));
1984             msi_component_set_state( component, INSTALLSTATE_LOCAL );
1985         }
1986
1987         TRACE("Result: Component %s (Installed %i, Action %i)\n",
1988             debugstr_w(component->Component), component->Installed, component->Action);
1989     }
1990
1991
1992     return ERROR_SUCCESS;
1993 }
1994
1995 static UINT ITERATE_CostFinalizeDirectories(MSIRECORD *row, LPVOID param)
1996 {
1997     MSIPACKAGE *package = (MSIPACKAGE*)param;
1998     LPCWSTR name;
1999     LPWSTR path;
2000     MSIFOLDER *f;
2001
2002     name = MSI_RecordGetString(row,1);
2003
2004     f = get_loaded_folder(package, name);
2005     if (!f) return ERROR_SUCCESS;
2006
2007     /* reset the ResolvedTarget */
2008     msi_free(f->ResolvedTarget);
2009     f->ResolvedTarget = NULL;
2010
2011     /* This helper function now does ALL the work */
2012     TRACE("Dir %s ...\n",debugstr_w(name));
2013     path = resolve_folder(package,name,FALSE,TRUE,TRUE,NULL);
2014     TRACE("resolves to %s\n",debugstr_w(path));
2015     msi_free(path);
2016
2017     return ERROR_SUCCESS;
2018 }
2019
2020 static UINT ITERATE_CostFinalizeConditions(MSIRECORD *row, LPVOID param)
2021 {
2022     MSIPACKAGE *package = (MSIPACKAGE*)param;
2023     LPCWSTR name;
2024     MSIFEATURE *feature;
2025
2026     name = MSI_RecordGetString( row, 1 );
2027
2028     feature = get_loaded_feature( package, name );
2029     if (!feature)
2030         ERR("FAILED to find loaded feature %s\n",debugstr_w(name));
2031     else
2032     {
2033         LPCWSTR Condition;
2034         Condition = MSI_RecordGetString(row,3);
2035
2036         if (MSI_EvaluateConditionW(package,Condition) == MSICONDITION_TRUE)
2037         {
2038             int level = MSI_RecordGetInteger(row,2);
2039             TRACE("Resetting feature %s to level %i\n", debugstr_w(name), level);
2040             feature->Level = level;
2041         }
2042     }
2043     return ERROR_SUCCESS;
2044 }
2045
2046 static LPWSTR msi_get_disk_file_version( LPCWSTR filename )
2047 {
2048     static const WCHAR name_fmt[] =
2049         {'%','u','.','%','u','.','%','u','.','%','u',0};
2050     static const WCHAR name[] = {'\\',0};
2051     VS_FIXEDFILEINFO *lpVer;
2052     WCHAR filever[0x100];
2053     LPVOID version;
2054     DWORD versize;
2055     DWORD handle;
2056     UINT sz;
2057
2058     TRACE("%s\n", debugstr_w(filename));
2059
2060     versize = GetFileVersionInfoSizeW( filename, &handle );
2061     if (!versize)
2062         return NULL;
2063
2064     version = msi_alloc( versize );
2065     GetFileVersionInfoW( filename, 0, versize, version );
2066
2067     if (!VerQueryValueW( version, name, (LPVOID*)&lpVer, &sz ))
2068     {
2069         msi_free( version );
2070         return NULL;
2071     }
2072
2073     sprintfW( filever, name_fmt,
2074         HIWORD(lpVer->dwFileVersionMS),
2075         LOWORD(lpVer->dwFileVersionMS),
2076         HIWORD(lpVer->dwFileVersionLS),
2077         LOWORD(lpVer->dwFileVersionLS));
2078
2079     msi_free( version );
2080
2081     return strdupW( filever );
2082 }
2083
2084 static UINT msi_check_file_install_states( MSIPACKAGE *package )
2085 {
2086     LPWSTR file_version;
2087     MSIFILE *file;
2088
2089     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2090     {
2091         MSICOMPONENT* comp = file->Component;
2092         LPWSTR p;
2093
2094         if (!comp)
2095             continue;
2096
2097         if (file->IsCompressed)
2098             comp->ForceLocalState = TRUE;
2099
2100         /* calculate target */
2101         p = resolve_folder(package, comp->Directory, FALSE, FALSE, TRUE, NULL);
2102
2103         msi_free(file->TargetPath);
2104
2105         TRACE("file %s is named %s\n",
2106                debugstr_w(file->File), debugstr_w(file->FileName));
2107
2108         file->TargetPath = build_directory_name(2, p, file->FileName);
2109
2110         msi_free(p);
2111
2112         TRACE("file %s resolves to %s\n",
2113                debugstr_w(file->File), debugstr_w(file->TargetPath));
2114
2115         /* don't check files of components that aren't installed */
2116         if (comp->Installed == INSTALLSTATE_UNKNOWN ||
2117             comp->Installed == INSTALLSTATE_ABSENT)
2118         {
2119             file->state = msifs_missing;  /* assume files are missing */
2120             continue;
2121         }
2122
2123         if (GetFileAttributesW(file->TargetPath) == INVALID_FILE_ATTRIBUTES)
2124         {
2125             file->state = msifs_missing;
2126             comp->Cost += file->FileSize;
2127             comp->Installed = INSTALLSTATE_INCOMPLETE;
2128             continue;
2129         }
2130
2131         if (file->Version &&
2132             (file_version = msi_get_disk_file_version( file->TargetPath )))
2133         {
2134             TRACE("new %s old %s\n", debugstr_w(file->Version),
2135                   debugstr_w(file_version));
2136             /* FIXME: seems like a bad way to compare version numbers */
2137             if (lstrcmpiW(file_version, file->Version)<0)
2138             {
2139                 file->state = msifs_overwrite;
2140                 comp->Cost += file->FileSize;
2141                 comp->Installed = INSTALLSTATE_INCOMPLETE;
2142             }
2143             else
2144                 file->state = msifs_present;
2145             msi_free( file_version );
2146         }
2147         else
2148             file->state = msifs_present;
2149     }
2150
2151     return ERROR_SUCCESS;
2152 }
2153
2154 /*
2155  * A lot is done in this function aside from just the costing.
2156  * The costing needs to be implemented at some point but for now I am going
2157  * to focus on the directory building
2158  *
2159  */
2160 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
2161 {
2162     static const WCHAR ExecSeqQuery[] =
2163         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2164          '`','D','i','r','e','c','t','o','r','y','`',0};
2165     static const WCHAR ConditionQuery[] =
2166         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2167          '`','C','o','n','d','i','t','i','o','n','`',0};
2168     static const WCHAR szCosting[] =
2169         {'C','o','s','t','i','n','g','C','o','m','p','l','e','t','e',0 };
2170     static const WCHAR szlevel[] =
2171         {'I','N','S','T','A','L','L','L','E','V','E','L',0};
2172     static const WCHAR szOutOfDiskSpace[] =
2173         {'O','u','t','O','f','D','i','s','k','S','p','a','c','e',0};
2174     static const WCHAR szOne[] = { '1', 0 };
2175     static const WCHAR szZero[] = { '0', 0 };
2176     MSICOMPONENT *comp;
2177     UINT rc;
2178     MSIQUERY * view;
2179     LPWSTR level;
2180
2181     if ( 1 == msi_get_property_int( package, szCosting, 0 ) )
2182         return ERROR_SUCCESS;
2183
2184     TRACE("Building Directory properties\n");
2185
2186     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2187     if (rc == ERROR_SUCCESS)
2188     {
2189         rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeDirectories,
2190                         package);
2191         msiobj_release(&view->hdr);
2192     }
2193
2194     /* read components states from the registry */
2195     ACTION_GetComponentInstallStates(package);
2196
2197     TRACE("File calculations\n");
2198     msi_check_file_install_states( package );
2199
2200     TRACE("Evaluating Condition Table\n");
2201
2202     rc = MSI_DatabaseOpenViewW(package->db, ConditionQuery, &view);
2203     if (rc == ERROR_SUCCESS)
2204     {
2205         rc = MSI_IterateRecords(view, NULL, ITERATE_CostFinalizeConditions,
2206                     package);
2207         msiobj_release(&view->hdr);
2208     }
2209
2210     TRACE("Enabling or Disabling Components\n");
2211     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2212     {
2213         if (MSI_EvaluateConditionW(package, comp->Condition) == MSICONDITION_FALSE)
2214         {
2215             TRACE("Disabling component %s\n", debugstr_w(comp->Component));
2216             comp->Enabled = FALSE;
2217         }
2218     }
2219
2220     MSI_SetPropertyW(package,szCosting,szOne);
2221     /* set default run level if not set */
2222     level = msi_dup_property( package, szlevel );
2223     if (!level)
2224         MSI_SetPropertyW(package,szlevel, szOne);
2225     msi_free(level);
2226
2227     /* FIXME: check volume disk space */
2228     MSI_SetPropertyW(package, szOutOfDiskSpace, szZero);
2229
2230     ACTION_UpdateFeatureInstallStates(package);
2231
2232     return MSI_SetFeatureStates(package);
2233 }
2234
2235 /* OK this value is "interpreted" and then formatted based on the
2236    first few characters */
2237 static LPSTR parse_value(MSIPACKAGE *package, LPCWSTR value, DWORD *type,
2238                          DWORD *size)
2239 {
2240     LPSTR data = NULL;
2241
2242     if (value[0]=='#' && value[1]!='#' && value[1]!='%')
2243     {
2244         if (value[1]=='x')
2245         {
2246             LPWSTR ptr;
2247             CHAR byte[5];
2248             LPWSTR deformated = NULL;
2249             int count;
2250
2251             deformat_string(package, &value[2], &deformated);
2252
2253             /* binary value type */
2254             ptr = deformated;
2255             *type = REG_BINARY;
2256             if (strlenW(ptr)%2)
2257                 *size = (strlenW(ptr)/2)+1;
2258             else
2259                 *size = strlenW(ptr)/2;
2260
2261             data = msi_alloc(*size);
2262
2263             byte[0] = '0';
2264             byte[1] = 'x';
2265             byte[4] = 0;
2266             count = 0;
2267             /* if uneven pad with a zero in front */
2268             if (strlenW(ptr)%2)
2269             {
2270                 byte[2]= '0';
2271                 byte[3]= *ptr;
2272                 ptr++;
2273                 data[count] = (BYTE)strtol(byte,NULL,0);
2274                 count ++;
2275                 TRACE("Uneven byte count\n");
2276             }
2277             while (*ptr)
2278             {
2279                 byte[2]= *ptr;
2280                 ptr++;
2281                 byte[3]= *ptr;
2282                 ptr++;
2283                 data[count] = (BYTE)strtol(byte,NULL,0);
2284                 count ++;
2285             }
2286             msi_free(deformated);
2287
2288             TRACE("Data %i bytes(%i)\n",*size,count);
2289         }
2290         else
2291         {
2292             LPWSTR deformated;
2293             LPWSTR p;
2294             DWORD d = 0;
2295             deformat_string(package, &value[1], &deformated);
2296
2297             *type=REG_DWORD;
2298             *size = sizeof(DWORD);
2299             data = msi_alloc(*size);
2300             p = deformated;
2301             if (*p == '-')
2302                 p++;
2303             while (*p)
2304             {
2305                 if ( (*p < '0') || (*p > '9') )
2306                     break;
2307                 d *= 10;
2308                 d += (*p - '0');
2309                 p++;
2310             }
2311             if (deformated[0] == '-')
2312                 d = -d;
2313             *(LPDWORD)data = d;
2314             TRACE("DWORD %i\n",*(LPDWORD)data);
2315
2316             msi_free(deformated);
2317         }
2318     }
2319     else
2320     {
2321         static const WCHAR szMulti[] = {'[','~',']',0};
2322         LPCWSTR ptr;
2323         *type=REG_SZ;
2324
2325         if (value[0]=='#')
2326         {
2327             if (value[1]=='%')
2328             {
2329                 ptr = &value[2];
2330                 *type=REG_EXPAND_SZ;
2331             }
2332             else
2333                 ptr = &value[1];
2334          }
2335          else
2336             ptr=value;
2337
2338         if (strstrW(value,szMulti))
2339             *type = REG_MULTI_SZ;
2340
2341         /* remove initial delimiter */
2342         if (!strncmpW(value, szMulti, 3))
2343             ptr = value + 3;
2344
2345         *size = deformat_string(package, ptr,(LPWSTR*)&data);
2346
2347         /* add double NULL terminator */
2348         if (*type == REG_MULTI_SZ)
2349         {
2350             *size += 2 * sizeof(WCHAR); /* two NULL terminators */
2351             data = msi_realloc_zero(data, *size);
2352         }
2353     }
2354     return data;
2355 }
2356
2357 static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
2358 {
2359     MSIPACKAGE *package = (MSIPACKAGE*)param;
2360     static const WCHAR szHCR[] =
2361         {'H','K','E','Y','_','C','L','A','S','S','E','S','_',
2362          'R','O','O','T','\\',0};
2363     static const WCHAR szHCU[] =
2364         {'H','K','E','Y','_','C','U','R','R','E','N','T','_',
2365          'U','S','E','R','\\',0};
2366     static const WCHAR szHLM[] =
2367         {'H','K','E','Y','_','L','O','C','A','L','_',
2368          'M','A','C','H','I','N','E','\\',0};
2369     static const WCHAR szHU[] =
2370         {'H','K','E','Y','_','U','S','E','R','S','\\',0};
2371
2372     LPSTR value_data = NULL;
2373     HKEY  root_key, hkey;
2374     DWORD type,size;
2375     LPWSTR  deformated;
2376     LPCWSTR szRoot, component, name, key, value;
2377     MSICOMPONENT *comp;
2378     MSIRECORD * uirow;
2379     LPWSTR uikey;
2380     INT   root;
2381     BOOL check_first = FALSE;
2382     UINT rc;
2383
2384     ui_progress(package,2,0,0,0);
2385
2386     value = NULL;
2387     key = NULL;
2388     uikey = NULL;
2389     name = NULL;
2390
2391     component = MSI_RecordGetString(row, 6);
2392     comp = get_loaded_component(package,component);
2393     if (!comp)
2394         return ERROR_SUCCESS;
2395
2396     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2397     {
2398         TRACE("Skipping write due to disabled component %s\n",
2399                         debugstr_w(component));
2400
2401         comp->Action = comp->Installed;
2402
2403         return ERROR_SUCCESS;
2404     }
2405
2406     comp->Action = INSTALLSTATE_LOCAL;
2407
2408     name = MSI_RecordGetString(row, 4);
2409     if( MSI_RecordIsNull(row,5) && name )
2410     {
2411         /* null values can have special meanings */
2412         if (name[0]=='-' && name[1] == 0)
2413                 return ERROR_SUCCESS;
2414         else if ((name[0]=='+' && name[1] == 0) ||
2415                  (name[0] == '*' && name[1] == 0))
2416                 name = NULL;
2417         check_first = TRUE;
2418     }
2419
2420     root = MSI_RecordGetInteger(row,2);
2421     key = MSI_RecordGetString(row, 3);
2422
2423     /* get the root key */
2424     switch (root)
2425     {
2426         case -1:
2427             {
2428                 static const WCHAR szALLUSER[] = {'A','L','L','U','S','E','R','S',0};
2429                 LPWSTR all_users = msi_dup_property( package, szALLUSER );
2430                 if (all_users && all_users[0] == '1')
2431                 {
2432                     root_key = HKEY_LOCAL_MACHINE;
2433                     szRoot = szHLM;
2434                 }
2435                 else
2436                 {
2437                     root_key = HKEY_CURRENT_USER;
2438                     szRoot = szHCU;
2439                 }
2440                 msi_free(all_users);
2441             }
2442                  break;
2443         case 0:  root_key = HKEY_CLASSES_ROOT;
2444                  szRoot = szHCR;
2445                  break;
2446         case 1:  root_key = HKEY_CURRENT_USER;
2447                  szRoot = szHCU;
2448                  break;
2449         case 2:  root_key = HKEY_LOCAL_MACHINE;
2450                  szRoot = szHLM;
2451                  break;
2452         case 3:  root_key = HKEY_USERS;
2453                  szRoot = szHU;
2454                  break;
2455         default:
2456                  ERR("Unknown root %i\n",root);
2457                  root_key=NULL;
2458                  szRoot = NULL;
2459                  break;
2460     }
2461     if (!root_key)
2462         return ERROR_SUCCESS;
2463
2464     deformat_string(package, key , &deformated);
2465     size = strlenW(deformated) + strlenW(szRoot) + 1;
2466     uikey = msi_alloc(size*sizeof(WCHAR));
2467     strcpyW(uikey,szRoot);
2468     strcatW(uikey,deformated);
2469
2470     if (RegCreateKeyW( root_key, deformated, &hkey))
2471     {
2472         ERR("Could not create key %s\n",debugstr_w(deformated));
2473         msi_free(deformated);
2474         msi_free(uikey);
2475         return ERROR_SUCCESS;
2476     }
2477     msi_free(deformated);
2478
2479     value = MSI_RecordGetString(row,5);
2480     if (value)
2481         value_data = parse_value(package, value, &type, &size);
2482     else
2483     {
2484         static const WCHAR szEmpty[] = {0};
2485         value_data = (LPSTR)strdupW(szEmpty);
2486         size = sizeof(szEmpty);
2487         type = REG_SZ;
2488     }
2489
2490     deformat_string(package, name, &deformated);
2491
2492     if (!check_first)
2493     {
2494         TRACE("Setting value %s of %s\n",debugstr_w(deformated),
2495                         debugstr_w(uikey));
2496         RegSetValueExW(hkey, deformated, 0, type, (LPBYTE)value_data, size);
2497     }
2498     else
2499     {
2500         DWORD sz = 0;
2501         rc = RegQueryValueExW(hkey, deformated, NULL, NULL, NULL, &sz);
2502         if (rc == ERROR_SUCCESS || rc == ERROR_MORE_DATA)
2503         {
2504             TRACE("value %s of %s checked already exists\n",
2505                             debugstr_w(deformated), debugstr_w(uikey));
2506         }
2507         else
2508         {
2509             TRACE("Checked and setting value %s of %s\n",
2510                             debugstr_w(deformated), debugstr_w(uikey));
2511             if (deformated || size)
2512                 RegSetValueExW(hkey, deformated, 0, type, (LPBYTE) value_data, size);
2513         }
2514     }
2515     RegCloseKey(hkey);
2516
2517     uirow = MSI_CreateRecord(3);
2518     MSI_RecordSetStringW(uirow,2,deformated);
2519     MSI_RecordSetStringW(uirow,1,uikey);
2520
2521     if (type == REG_SZ)
2522         MSI_RecordSetStringW(uirow,3,(LPWSTR)value_data);
2523     else
2524         MSI_RecordSetStringW(uirow,3,value);
2525
2526     ui_actiondata(package,szWriteRegistryValues,uirow);
2527     msiobj_release( &uirow->hdr );
2528
2529     msi_free(value_data);
2530     msi_free(deformated);
2531     msi_free(uikey);
2532
2533     return ERROR_SUCCESS;
2534 }
2535
2536 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
2537 {
2538     UINT rc;
2539     MSIQUERY * view;
2540     static const WCHAR ExecSeqQuery[] =
2541         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2542          '`','R','e','g','i','s','t','r','y','`',0 };
2543
2544     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2545     if (rc != ERROR_SUCCESS)
2546         return ERROR_SUCCESS;
2547
2548     /* increment progress bar each time action data is sent */
2549     ui_progress(package,1,REG_PROGRESS_VALUE,1,0);
2550
2551     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteRegistryValues, package);
2552
2553     msiobj_release(&view->hdr);
2554     return rc;
2555 }
2556
2557 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
2558 {
2559     package->script->CurrentlyScripting = TRUE;
2560
2561     return ERROR_SUCCESS;
2562 }
2563
2564
2565 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
2566 {
2567     MSICOMPONENT *comp;
2568     DWORD progress = 0;
2569     DWORD total = 0;
2570     static const WCHAR q1[]=
2571         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
2572          '`','R','e','g','i','s','t','r','y','`',0};
2573     UINT rc;
2574     MSIQUERY * view;
2575     MSIFEATURE *feature;
2576     MSIFILE *file;
2577
2578     TRACE("InstallValidate\n");
2579
2580     rc = MSI_DatabaseOpenViewW(package->db, q1, &view);
2581     if (rc == ERROR_SUCCESS)
2582     {
2583         MSI_IterateRecords( view, &progress, NULL, package );
2584         msiobj_release( &view->hdr );
2585         total += progress * REG_PROGRESS_VALUE;
2586     }
2587
2588     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2589         total += COMPONENT_PROGRESS_VALUE;
2590
2591     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2592         total += file->FileSize;
2593
2594     ui_progress(package,0,total,0,0);
2595
2596     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2597     {
2598         TRACE("Feature: %s; Installed: %i; Action %i; Request %i\n",
2599             debugstr_w(feature->Feature), feature->Installed, feature->Action,
2600             feature->ActionRequest);
2601     }
2602
2603     return ERROR_SUCCESS;
2604 }
2605
2606 static UINT ITERATE_LaunchConditions(MSIRECORD *row, LPVOID param)
2607 {
2608     MSIPACKAGE* package = (MSIPACKAGE*)param;
2609     LPCWSTR cond = NULL;
2610     LPCWSTR message = NULL;
2611     UINT r;
2612
2613     static const WCHAR title[]=
2614         {'I','n','s','t','a','l','l',' ','F','a', 'i','l','e','d',0};
2615
2616     cond = MSI_RecordGetString(row,1);
2617
2618     r = MSI_EvaluateConditionW(package,cond);
2619     if (r == MSICONDITION_FALSE)
2620     {
2621         if ((gUILevel & INSTALLUILEVEL_MASK) != INSTALLUILEVEL_NONE)
2622         {
2623             LPWSTR deformated;
2624             message = MSI_RecordGetString(row,2);
2625             deformat_string(package,message,&deformated);
2626             MessageBoxW(NULL,deformated,title,MB_OK);
2627             msi_free(deformated);
2628         }
2629
2630         return ERROR_INSTALL_FAILURE;
2631     }
2632
2633     return ERROR_SUCCESS;
2634 }
2635
2636 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
2637 {
2638     UINT rc;
2639     MSIQUERY * view = NULL;
2640     static const WCHAR ExecSeqQuery[] =
2641         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2642          '`','L','a','u','n','c','h','C','o','n','d','i','t','i','o','n','`',0};
2643
2644     TRACE("Checking launch conditions\n");
2645
2646     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
2647     if (rc != ERROR_SUCCESS)
2648         return ERROR_SUCCESS;
2649
2650     rc = MSI_IterateRecords(view, NULL, ITERATE_LaunchConditions, package);
2651     msiobj_release(&view->hdr);
2652
2653     return rc;
2654 }
2655
2656 static LPWSTR resolve_keypath( MSIPACKAGE* package, MSICOMPONENT *cmp )
2657 {
2658
2659     if (!cmp->KeyPath)
2660         return resolve_folder(package,cmp->Directory,FALSE,FALSE,TRUE,NULL);
2661
2662     if (cmp->Attributes & msidbComponentAttributesRegistryKeyPath)
2663     {
2664         MSIRECORD * row = 0;
2665         UINT root,len;
2666         LPWSTR deformated,buffer,deformated_name;
2667         LPCWSTR key,name;
2668         static const WCHAR ExecSeqQuery[] =
2669             {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2670              '`','R','e','g','i','s','t','r','y','`',' ',
2671              'W','H','E','R','E',' ', '`','R','e','g','i','s','t','r','y','`',
2672              ' ','=',' ' ,'\'','%','s','\'',0 };
2673         static const WCHAR fmt[]={'%','0','2','i',':','\\','%','s','\\',0};
2674         static const WCHAR fmt2[]=
2675             {'%','0','2','i',':','\\','%','s','\\','%','s',0};
2676
2677         row = MSI_QueryGetRecord(package->db, ExecSeqQuery,cmp->KeyPath);
2678         if (!row)
2679             return NULL;
2680
2681         root = MSI_RecordGetInteger(row,2);
2682         key = MSI_RecordGetString(row, 3);
2683         name = MSI_RecordGetString(row, 4);
2684         deformat_string(package, key , &deformated);
2685         deformat_string(package, name, &deformated_name);
2686
2687         len = strlenW(deformated) + 6;
2688         if (deformated_name)
2689             len+=strlenW(deformated_name);
2690
2691         buffer = msi_alloc( len *sizeof(WCHAR));
2692
2693         if (deformated_name)
2694             sprintfW(buffer,fmt2,root,deformated,deformated_name);
2695         else
2696             sprintfW(buffer,fmt,root,deformated);
2697
2698         msi_free(deformated);
2699         msi_free(deformated_name);
2700         msiobj_release(&row->hdr);
2701
2702         return buffer;
2703     }
2704     else if (cmp->Attributes & msidbComponentAttributesODBCDataSource)
2705     {
2706         FIXME("UNIMPLEMENTED keypath as ODBC Source\n");
2707         return NULL;
2708     }
2709     else
2710     {
2711         MSIFILE *file = get_loaded_file( package, cmp->KeyPath );
2712
2713         if (file)
2714             return strdupW( file->TargetPath );
2715     }
2716     return NULL;
2717 }
2718
2719 static HKEY openSharedDLLsKey(void)
2720 {
2721     HKEY hkey=0;
2722     static const WCHAR path[] =
2723         {'S','o','f','t','w','a','r','e','\\',
2724          'M','i','c','r','o','s','o','f','t','\\',
2725          'W','i','n','d','o','w','s','\\',
2726          'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2727          'S','h','a','r','e','d','D','L','L','s',0};
2728
2729     RegCreateKeyW(HKEY_LOCAL_MACHINE,path,&hkey);
2730     return hkey;
2731 }
2732
2733 static UINT ACTION_GetSharedDLLsCount(LPCWSTR dll)
2734 {
2735     HKEY hkey;
2736     DWORD count=0;
2737     DWORD type;
2738     DWORD sz = sizeof(count);
2739     DWORD rc;
2740
2741     hkey = openSharedDLLsKey();
2742     rc = RegQueryValueExW(hkey, dll, NULL, &type, (LPBYTE)&count, &sz);
2743     if (rc != ERROR_SUCCESS)
2744         count = 0;
2745     RegCloseKey(hkey);
2746     return count;
2747 }
2748
2749 static UINT ACTION_WriteSharedDLLsCount(LPCWSTR path, UINT count)
2750 {
2751     HKEY hkey;
2752
2753     hkey = openSharedDLLsKey();
2754     if (count > 0)
2755         msi_reg_set_val_dword( hkey, path, count );
2756     else
2757         RegDeleteValueW(hkey,path);
2758     RegCloseKey(hkey);
2759     return count;
2760 }
2761
2762 /*
2763  * Return TRUE if the count should be written out and FALSE if not
2764  */
2765 static void ACTION_RefCountComponent( MSIPACKAGE* package, MSICOMPONENT *comp )
2766 {
2767     MSIFEATURE *feature;
2768     INT count = 0;
2769     BOOL write = FALSE;
2770
2771     /* only refcount DLLs */
2772     if (comp->KeyPath == NULL ||
2773         comp->Attributes & msidbComponentAttributesRegistryKeyPath ||
2774         comp->Attributes & msidbComponentAttributesODBCDataSource)
2775         write = FALSE;
2776     else
2777     {
2778         count = ACTION_GetSharedDLLsCount( comp->FullKeypath);
2779         write = (count > 0);
2780
2781         if (comp->Attributes & msidbComponentAttributesSharedDllRefCount)
2782             write = TRUE;
2783     }
2784
2785     /* increment counts */
2786     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2787     {
2788         ComponentList *cl;
2789
2790         if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ))
2791             continue;
2792
2793         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2794         {
2795             if ( cl->component == comp )
2796                 count++;
2797         }
2798     }
2799
2800     /* decrement counts */
2801     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
2802     {
2803         ComponentList *cl;
2804
2805         if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ABSENT ))
2806             continue;
2807
2808         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
2809         {
2810             if ( cl->component == comp )
2811                 count--;
2812         }
2813     }
2814
2815     /* ref count all the files in the component */
2816     if (write)
2817     {
2818         MSIFILE *file;
2819
2820         LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2821         {
2822             if (file->Component == comp)
2823                 ACTION_WriteSharedDLLsCount( file->TargetPath, count );
2824         }
2825     }
2826
2827     /* add a count for permanent */
2828     if (comp->Attributes & msidbComponentAttributesPermanent)
2829         count ++;
2830
2831     comp->RefCount = count;
2832
2833     if (write)
2834         ACTION_WriteSharedDLLsCount( comp->FullKeypath, comp->RefCount );
2835 }
2836
2837 /*
2838  * Ok further analysis makes me think that this work is
2839  * actually done in the PublishComponents and PublishFeatures
2840  * step, and not here.  It appears like the keypath and all that is
2841  * resolved in this step, however actually written in the Publish steps.
2842  * But we will leave it here for now because it is unclear
2843  */
2844 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
2845 {
2846     WCHAR squished_pc[GUID_SIZE];
2847     WCHAR squished_cc[GUID_SIZE];
2848     UINT rc;
2849     MSICOMPONENT *comp;
2850     HKEY hkey;
2851
2852     TRACE("\n");
2853
2854     /* writes the Component values to the registry */
2855
2856     squash_guid(package->ProductCode,squished_pc);
2857     ui_progress(package,1,COMPONENT_PROGRESS_VALUE,1,0);
2858
2859     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2860     {
2861         MSIRECORD * uirow;
2862
2863         ui_progress(package,2,0,0,0);
2864         if (!comp->ComponentId)
2865             continue;
2866
2867         squash_guid(comp->ComponentId,squished_cc);
2868
2869         msi_free(comp->FullKeypath);
2870         comp->FullKeypath = resolve_keypath( package, comp );
2871
2872         /* do the refcounting */
2873         ACTION_RefCountComponent( package, comp );
2874
2875         TRACE("Component %s (%s), Keypath=%s, RefCount=%i\n",
2876                             debugstr_w(comp->Component),
2877                             debugstr_w(squished_cc),
2878                             debugstr_w(comp->FullKeypath),
2879                             comp->RefCount);
2880         /*
2881          * Write the keypath out if the component is to be registered
2882          * and delete the key if the component is to be unregistered
2883          */
2884         if (ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
2885         {
2886             if (!comp->FullKeypath)
2887                 continue;
2888
2889             if (package->Context == MSIINSTALLCONTEXT_MACHINE)
2890                 rc = MSIREG_OpenLocalUserDataComponentKey(comp->ComponentId, &hkey, TRUE);
2891             else
2892                 rc = MSIREG_OpenUserDataComponentKey(comp->ComponentId, &hkey, TRUE);
2893
2894             if (rc != ERROR_SUCCESS)
2895                 continue;
2896
2897             if (comp->Attributes & msidbComponentAttributesPermanent)
2898             {
2899                 static const WCHAR szPermKey[] =
2900                     { '0','0','0','0','0','0','0','0','0','0','0','0',
2901                       '0','0','0','0','0','0','0','0','0','0','0','0',
2902                       '0','0','0','0','0','0','0','0',0 };
2903
2904                 msi_reg_set_val_str(hkey, szPermKey, comp->FullKeypath);
2905             }
2906
2907             msi_reg_set_val_str(hkey, squished_pc, comp->FullKeypath);
2908             RegCloseKey(hkey);
2909         }
2910         else if (ACTION_VerifyComponentForAction(comp, INSTALLSTATE_ABSENT))
2911         {
2912             if (package->Context == MSIINSTALLCONTEXT_MACHINE)
2913                 MSIREG_DeleteLocalUserDataComponentKey(comp->ComponentId);
2914             else
2915                 MSIREG_DeleteUserDataComponentKey(comp->ComponentId);
2916         }
2917
2918         /* UI stuff */
2919         uirow = MSI_CreateRecord(3);
2920         MSI_RecordSetStringW(uirow,1,package->ProductCode);
2921         MSI_RecordSetStringW(uirow,2,comp->ComponentId);
2922         MSI_RecordSetStringW(uirow,3,comp->FullKeypath);
2923         ui_actiondata(package,szProcessComponents,uirow);
2924         msiobj_release( &uirow->hdr );
2925     }
2926
2927     return ERROR_SUCCESS;
2928 }
2929
2930 typedef struct {
2931     CLSID       clsid;
2932     LPWSTR      source;
2933
2934     LPWSTR      path;
2935     ITypeLib    *ptLib;
2936 } typelib_struct;
2937
2938 static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
2939                                        LPWSTR lpszName, LONG_PTR lParam)
2940 {
2941     TLIBATTR *attr;
2942     typelib_struct *tl_struct = (typelib_struct*) lParam;
2943     static const WCHAR fmt[] = {'%','s','\\','%','i',0};
2944     int sz;
2945     HRESULT res;
2946
2947     if (!IS_INTRESOURCE(lpszName))
2948     {
2949         ERR("Not Int Resource Name %s\n",debugstr_w(lpszName));
2950         return TRUE;
2951     }
2952
2953     sz = strlenW(tl_struct->source)+4;
2954     sz *= sizeof(WCHAR);
2955
2956     if ((INT_PTR)lpszName == 1)
2957         tl_struct->path = strdupW(tl_struct->source);
2958     else
2959     {
2960         tl_struct->path = msi_alloc(sz);
2961         sprintfW(tl_struct->path,fmt,tl_struct->source, lpszName);
2962     }
2963
2964     TRACE("trying %s\n", debugstr_w(tl_struct->path));
2965     res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
2966     if (!SUCCEEDED(res))
2967     {
2968         msi_free(tl_struct->path);
2969         tl_struct->path = NULL;
2970
2971         return TRUE;
2972     }
2973
2974     ITypeLib_GetLibAttr(tl_struct->ptLib, &attr);
2975     if (IsEqualGUID(&(tl_struct->clsid),&(attr->guid)))
2976     {
2977         ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
2978         return FALSE;
2979     }
2980
2981     msi_free(tl_struct->path);
2982     tl_struct->path = NULL;
2983
2984     ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
2985     ITypeLib_Release(tl_struct->ptLib);
2986
2987     return TRUE;
2988 }
2989
2990 static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
2991 {
2992     MSIPACKAGE* package = (MSIPACKAGE*)param;
2993     LPCWSTR component;
2994     MSICOMPONENT *comp;
2995     MSIFILE *file;
2996     typelib_struct tl_struct;
2997     HMODULE module;
2998     static const WCHAR szTYPELIB[] = {'T','Y','P','E','L','I','B',0};
2999
3000     component = MSI_RecordGetString(row,3);
3001     comp = get_loaded_component(package,component);
3002     if (!comp)
3003         return ERROR_SUCCESS;
3004
3005     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
3006     {
3007         TRACE("Skipping typelib reg due to disabled component\n");
3008
3009         comp->Action = comp->Installed;
3010
3011         return ERROR_SUCCESS;
3012     }
3013
3014     comp->Action = INSTALLSTATE_LOCAL;
3015
3016     file = get_loaded_file( package, comp->KeyPath );
3017     if (!file)
3018         return ERROR_SUCCESS;
3019
3020     module = LoadLibraryExW( file->TargetPath, NULL, LOAD_LIBRARY_AS_DATAFILE );
3021     if (module)
3022     {
3023         LPCWSTR guid;
3024         guid = MSI_RecordGetString(row,1);
3025         CLSIDFromString((LPWSTR)guid, &tl_struct.clsid);
3026         tl_struct.source = strdupW( file->TargetPath );
3027         tl_struct.path = NULL;
3028
3029         EnumResourceNamesW(module, szTYPELIB, Typelib_EnumResNameProc,
3030                         (LONG_PTR)&tl_struct);
3031
3032         if (tl_struct.path)
3033         {
3034             LPWSTR help = NULL;
3035             LPCWSTR helpid;
3036             HRESULT res;
3037
3038             helpid = MSI_RecordGetString(row,6);
3039
3040             if (helpid)
3041                 help = resolve_folder(package,helpid,FALSE,FALSE,TRUE,NULL);
3042             res = RegisterTypeLib(tl_struct.ptLib,tl_struct.path,help);
3043             msi_free(help);
3044
3045             if (!SUCCEEDED(res))
3046                 ERR("Failed to register type library %s\n",
3047                         debugstr_w(tl_struct.path));
3048             else
3049             {
3050                 ui_actiondata(package,szRegisterTypeLibraries,row);
3051
3052                 TRACE("Registered %s\n", debugstr_w(tl_struct.path));
3053             }
3054
3055             ITypeLib_Release(tl_struct.ptLib);
3056             msi_free(tl_struct.path);
3057         }
3058         else
3059             ERR("Failed to load type library %s\n",
3060                     debugstr_w(tl_struct.source));
3061
3062         FreeLibrary(module);
3063         msi_free(tl_struct.source);
3064     }
3065     else
3066         ERR("Could not load file! %s\n", debugstr_w(file->TargetPath));
3067
3068     return ERROR_SUCCESS;
3069 }
3070
3071 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
3072 {
3073     /*
3074      * OK this is a bit confusing.. I am given a _Component key and I believe
3075      * that the file that is being registered as a type library is the "key file
3076      * of that component" which I interpret to mean "The file in the KeyPath of
3077      * that component".
3078      */
3079     UINT rc;
3080     MSIQUERY * view;
3081     static const WCHAR Query[] =
3082         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3083          '`','T','y','p','e','L','i','b','`',0};
3084
3085     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3086     if (rc != ERROR_SUCCESS)
3087         return ERROR_SUCCESS;
3088
3089     rc = MSI_IterateRecords(view, NULL, ITERATE_RegisterTypeLibraries, package);
3090     msiobj_release(&view->hdr);
3091     return rc;
3092 }
3093
3094 static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
3095 {
3096     MSIPACKAGE *package = (MSIPACKAGE*)param;
3097     LPWSTR target_file, target_folder, filename;
3098     LPCWSTR buffer, extension;
3099     MSICOMPONENT *comp;
3100     static const WCHAR szlnk[]={'.','l','n','k',0};
3101     IShellLinkW *sl = NULL;
3102     IPersistFile *pf = NULL;
3103     HRESULT res;
3104
3105     buffer = MSI_RecordGetString(row,4);
3106     comp = get_loaded_component(package,buffer);
3107     if (!comp)
3108         return ERROR_SUCCESS;
3109
3110     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ))
3111     {
3112         TRACE("Skipping shortcut creation due to disabled component\n");
3113
3114         comp->Action = comp->Installed;
3115
3116         return ERROR_SUCCESS;
3117     }
3118
3119     comp->Action = INSTALLSTATE_LOCAL;
3120
3121     ui_actiondata(package,szCreateShortcuts,row);
3122
3123     res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3124                     &IID_IShellLinkW, (LPVOID *) &sl );
3125
3126     if (FAILED( res ))
3127     {
3128         ERR("CLSID_ShellLink not available\n");
3129         goto err;
3130     }
3131
3132     res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
3133     if (FAILED( res ))
3134     {
3135         ERR("QueryInterface(IID_IPersistFile) failed\n");
3136         goto err;
3137     }
3138
3139     buffer = MSI_RecordGetString(row,2);
3140     target_folder = resolve_folder(package, buffer,FALSE,FALSE,TRUE,NULL);
3141
3142     /* may be needed because of a bug somewhere else */
3143     create_full_pathW(target_folder);
3144
3145     filename = msi_dup_record_field( row, 3 );
3146     reduce_to_longfilename(filename);
3147
3148     extension = strchrW(filename,'.');
3149     if (!extension || strcmpiW(extension,szlnk))
3150     {
3151         int len = strlenW(filename);
3152         filename = msi_realloc(filename, len * sizeof(WCHAR) + sizeof(szlnk));
3153         memcpy(filename + len, szlnk, sizeof(szlnk));
3154     }
3155     target_file = build_directory_name(2, target_folder, filename);
3156     msi_free(target_folder);
3157     msi_free(filename);
3158
3159     buffer = MSI_RecordGetString(row,5);
3160     if (strchrW(buffer,'['))
3161     {
3162         LPWSTR deformated;
3163         deformat_string(package,buffer,&deformated);
3164         IShellLinkW_SetPath(sl,deformated);
3165         msi_free(deformated);
3166     }
3167     else
3168     {
3169         FIXME("poorly handled shortcut format, advertised shortcut\n");
3170         IShellLinkW_SetPath(sl,comp->FullKeypath);
3171     }
3172
3173     if (!MSI_RecordIsNull(row,6))
3174     {
3175         LPWSTR deformated;
3176         buffer = MSI_RecordGetString(row,6);
3177         deformat_string(package,buffer,&deformated);
3178         IShellLinkW_SetArguments(sl,deformated);
3179         msi_free(deformated);
3180     }
3181
3182     if (!MSI_RecordIsNull(row,7))
3183     {
3184         buffer = MSI_RecordGetString(row,7);
3185         IShellLinkW_SetDescription(sl,buffer);
3186     }
3187
3188     if (!MSI_RecordIsNull(row,8))
3189         IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
3190
3191     if (!MSI_RecordIsNull(row,9))
3192     {
3193         LPWSTR Path;
3194         INT index;
3195
3196         buffer = MSI_RecordGetString(row,9);
3197
3198         Path = build_icon_path(package,buffer);
3199         index = MSI_RecordGetInteger(row,10);
3200
3201         /* no value means 0 */
3202         if (index == MSI_NULL_INTEGER)
3203             index = 0;
3204
3205         IShellLinkW_SetIconLocation(sl,Path,index);
3206         msi_free(Path);
3207     }
3208
3209     if (!MSI_RecordIsNull(row,11))
3210         IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
3211
3212     if (!MSI_RecordIsNull(row,12))
3213     {
3214         LPWSTR Path;
3215         buffer = MSI_RecordGetString(row,12);
3216         Path = resolve_folder(package, buffer, FALSE, FALSE, TRUE, NULL);
3217         if (Path)
3218             IShellLinkW_SetWorkingDirectory(sl,Path);
3219         msi_free(Path);
3220     }
3221
3222     TRACE("Writing shortcut to %s\n",debugstr_w(target_file));
3223     IPersistFile_Save(pf,target_file,FALSE);
3224
3225     msi_free(target_file);
3226
3227 err:
3228     if (pf)
3229         IPersistFile_Release( pf );
3230     if (sl)
3231         IShellLinkW_Release( sl );
3232
3233     return ERROR_SUCCESS;
3234 }
3235
3236 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
3237 {
3238     UINT rc;
3239     HRESULT res;
3240     MSIQUERY * view;
3241     static const WCHAR Query[] =
3242         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3243          '`','S','h','o','r','t','c','u','t','`',0};
3244
3245     rc = MSI_DatabaseOpenViewW(package->db, Query, &view);
3246     if (rc != ERROR_SUCCESS)
3247         return ERROR_SUCCESS;
3248
3249     res = CoInitialize( NULL );
3250     if (FAILED (res))
3251     {
3252         ERR("CoInitialize failed\n");
3253         return ERROR_FUNCTION_FAILED;
3254     }
3255
3256     rc = MSI_IterateRecords(view, NULL, ITERATE_CreateShortcuts, package);
3257     msiobj_release(&view->hdr);
3258
3259     CoUninitialize();
3260
3261     return rc;
3262 }
3263
3264 static UINT ITERATE_PublishIcon(MSIRECORD *row, LPVOID param)
3265 {
3266     MSIPACKAGE* package = (MSIPACKAGE*)param;
3267     HANDLE the_file;
3268     LPWSTR FilePath;
3269     LPCWSTR FileName;
3270     CHAR buffer[1024];
3271     DWORD sz;
3272     UINT rc;
3273     MSIRECORD *uirow;
3274
3275     FileName = MSI_RecordGetString(row,1);
3276     if (!FileName)
3277     {
3278         ERR("Unable to get FileName\n");
3279         return ERROR_SUCCESS;
3280     }
3281
3282     FilePath = build_icon_path(package,FileName);
3283
3284     TRACE("Creating icon file at %s\n",debugstr_w(FilePath));
3285
3286     the_file = CreateFileW(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
3287                         FILE_ATTRIBUTE_NORMAL, NULL);
3288
3289     if (the_file == INVALID_HANDLE_VALUE)
3290     {
3291         ERR("Unable to create file %s\n",debugstr_w(FilePath));
3292         msi_free(FilePath);
3293         return ERROR_SUCCESS;
3294     }
3295
3296     do
3297     {
3298         DWORD write;
3299         sz = 1024;
3300         rc = MSI_RecordReadStream(row,2,buffer,&sz);
3301         if (rc != ERROR_SUCCESS)
3302         {
3303             ERR("Failed to get stream\n");
3304             CloseHandle(the_file);
3305             DeleteFileW(FilePath);
3306             break;
3307         }
3308         WriteFile(the_file,buffer,sz,&write,NULL);
3309     } while (sz == 1024);
3310
3311     msi_free(FilePath);
3312
3313     CloseHandle(the_file);
3314
3315     uirow = MSI_CreateRecord(1);
3316     MSI_RecordSetStringW(uirow,1,FileName);
3317     ui_actiondata(package,szPublishProduct,uirow);
3318     msiobj_release( &uirow->hdr );
3319
3320     return ERROR_SUCCESS;
3321 }
3322
3323 static UINT msi_publish_icons(MSIPACKAGE *package)
3324 {
3325     UINT r;
3326     MSIQUERY *view;
3327
3328     static const WCHAR query[]= {
3329         'S','E','L','E','C','T',' ','*',' ',
3330         'F','R','O','M',' ','`','I','c','o','n','`',0};
3331
3332     r = MSI_DatabaseOpenViewW(package->db, query, &view);
3333     if (r == ERROR_SUCCESS)
3334     {
3335         MSI_IterateRecords(view, NULL, ITERATE_PublishIcon, package);
3336         msiobj_release(&view->hdr);
3337     }
3338
3339     return ERROR_SUCCESS;
3340 }
3341
3342 static UINT msi_publish_sourcelist(MSIPACKAGE *package, HKEY hkey)
3343 {
3344     UINT r;
3345     HKEY source;
3346     LPWSTR buffer;
3347     MSIMEDIADISK *disk;
3348     MSISOURCELISTINFO *info;
3349
3350     static const WCHAR szEmpty[] = {0};
3351     static const WCHAR szSourceList[] = {'S','o','u','r','c','e','L','i','s','t',0};
3352
3353     r = RegCreateKeyW(hkey, szSourceList, &source);
3354     if (r != ERROR_SUCCESS)
3355         return r;
3356
3357     RegCloseKey(source);
3358
3359     buffer = strrchrW(package->PackagePath, '\\') + 1;
3360     r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3361                               package->Context, MSICODE_PRODUCT,
3362                               INSTALLPROPERTY_PACKAGENAMEW, buffer);
3363     if (r != ERROR_SUCCESS)
3364         return r;
3365
3366     r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3367                               package->Context, MSICODE_PRODUCT,
3368                               INSTALLPROPERTY_MEDIAPACKAGEPATHW, szEmpty);
3369     if (r != ERROR_SUCCESS)
3370         return r;
3371
3372     r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3373                               package->Context, MSICODE_PRODUCT,
3374                               INSTALLPROPERTY_DISKPROMPTW, szEmpty);
3375     if (r != ERROR_SUCCESS)
3376         return r;
3377
3378     LIST_FOR_EACH_ENTRY(info, &package->sourcelist_info, MSISOURCELISTINFO, entry)
3379     {
3380         if (!lstrcmpW(info->property, INSTALLPROPERTY_LASTUSEDSOURCEW))
3381             msi_set_last_used_source(package->ProductCode, NULL, info->context,
3382                                      info->options, info->value);
3383         else
3384             MsiSourceListSetInfoW(package->ProductCode, NULL,
3385                                   info->context, info->options,
3386                                   info->property, info->value);
3387     }
3388
3389     LIST_FOR_EACH_ENTRY(disk, &package->sourcelist_media, MSIMEDIADISK, entry)
3390     {
3391         MsiSourceListAddMediaDiskW(package->ProductCode, NULL,
3392                                    disk->context, disk->options,
3393                                    disk->disk_id, disk->volume_label, disk->disk_prompt);
3394     }
3395
3396     return ERROR_SUCCESS;
3397 }
3398
3399 static UINT msi_publish_product_properties(MSIPACKAGE *package, HKEY hkey)
3400 {
3401     MSIHANDLE hdb, suminfo;
3402     WCHAR guids[MAX_PATH];
3403     WCHAR packcode[SQUISH_GUID_SIZE];
3404     LPWSTR buffer;
3405     LPWSTR ptr;
3406     DWORD langid;
3407     DWORD size;
3408     UINT r;
3409
3410     static const WCHAR szProductLanguage[] =
3411         {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
3412     static const WCHAR szARPProductIcon[] =
3413         {'A','R','P','P','R','O','D','U','C','T','I','C','O','N',0};
3414     static const WCHAR szProductVersion[] =
3415         {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
3416     static const WCHAR szAssignment[] =
3417         {'A','s','s','i','g','n','m','e','n','t',0};
3418     static const WCHAR szAdvertiseFlags[] =
3419         {'A','d','v','e','r','t','i','s','e','F','l','a','g','s',0};
3420     static const WCHAR szClients[] =
3421         {'C','l','i','e','n','t','s',0};
3422     static const WCHAR szColon[] = {':',0};
3423
3424     buffer = msi_dup_property(package, INSTALLPROPERTY_PRODUCTNAMEW);
3425     msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTNAMEW, buffer);
3426     msi_free(buffer);
3427
3428     langid = msi_get_property_int(package, szProductLanguage, 0);
3429     msi_reg_set_val_dword(hkey, INSTALLPROPERTY_LANGUAGEW, langid);
3430
3431     ptr = strrchrW(package->PackagePath, '\\' ) + 1;
3432     msi_reg_set_val_str(hkey, INSTALLPROPERTY_PACKAGENAMEW, ptr);
3433
3434     /* FIXME */
3435     msi_reg_set_val_dword(hkey, INSTALLPROPERTY_AUTHORIZED_LUA_APPW, 0);
3436
3437     buffer = msi_dup_property(package, szARPProductIcon);
3438     if (buffer)
3439     {
3440         LPWSTR path = build_icon_path(package,buffer);
3441         msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTICONW, path);
3442         msi_free(path);
3443         msi_free(buffer);
3444     }
3445
3446     buffer = msi_dup_property(package, szProductVersion);
3447     if (buffer)
3448     {
3449         DWORD verdword = msi_version_str_to_dword(buffer);
3450         msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONW, verdword);
3451         msi_free(buffer);
3452     }
3453
3454     msi_reg_set_val_dword(hkey, szAssignment, 0);
3455     msi_reg_set_val_dword(hkey, szAdvertiseFlags, 0x184);
3456     msi_reg_set_val_dword(hkey, INSTALLPROPERTY_INSTANCETYPEW, 0);
3457     msi_reg_set_val_str(hkey, szClients, szColon);
3458
3459     hdb = alloc_msihandle(&package->db->hdr);
3460     if (!hdb)
3461         return ERROR_NOT_ENOUGH_MEMORY;
3462
3463     r = MsiGetSummaryInformationW(hdb, NULL, 0, &suminfo);
3464     MsiCloseHandle(hdb);
3465     if (r != ERROR_SUCCESS)
3466         goto done;
3467
3468     size = MAX_PATH;
3469     r = MsiSummaryInfoGetPropertyW(suminfo, PID_REVNUMBER, NULL, NULL,
3470                                    NULL, guids, &size);
3471     if (r != ERROR_SUCCESS)
3472         goto done;
3473
3474     ptr = strchrW(guids, ';');
3475     if (ptr) *ptr = 0;
3476     squash_guid(guids, packcode);
3477     msi_reg_set_val_str(hkey, INSTALLPROPERTY_PACKAGECODEW, packcode);
3478
3479 done:
3480     MsiCloseHandle(suminfo);
3481     return ERROR_SUCCESS;
3482 }
3483
3484 static UINT msi_publish_upgrade_code(MSIPACKAGE *package)
3485 {
3486     UINT r;
3487     HKEY hkey;
3488     LPWSTR upgrade;
3489     WCHAR squashed_pc[SQUISH_GUID_SIZE];
3490
3491     static const WCHAR szUpgradeCode[] =
3492         {'U','p','g','r','a','d','e','C','o','d','e',0};
3493
3494     upgrade = msi_dup_property(package, szUpgradeCode);
3495     if (!upgrade)
3496         return ERROR_SUCCESS;
3497
3498     if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3499     {
3500         r = MSIREG_OpenClassesUpgradeCodesKey(upgrade, &hkey, TRUE);
3501         if (r != ERROR_SUCCESS)
3502             goto done;
3503     }
3504     else
3505     {
3506         r = MSIREG_OpenUserUpgradeCodesKey(upgrade, &hkey, TRUE);
3507         if (r != ERROR_SUCCESS)
3508             goto done;
3509     }
3510
3511     squash_guid(package->ProductCode, squashed_pc);
3512     msi_reg_set_val_str(hkey, squashed_pc, NULL);
3513
3514     RegCloseKey(hkey);
3515
3516 done:
3517     msi_free(upgrade);
3518     return r;
3519 }
3520
3521 static BOOL msi_check_publish(MSIPACKAGE *package)
3522 {
3523     MSIFEATURE *feature;
3524
3525     LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
3526     {
3527         if (feature->ActionRequest == INSTALLSTATE_LOCAL)
3528             return TRUE;
3529     }
3530
3531     return FALSE;
3532 }
3533
3534 static BOOL msi_check_unpublish(MSIPACKAGE *package)
3535 {
3536     MSIFEATURE *feature;
3537
3538     LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
3539     {
3540         if (feature->ActionRequest != INSTALLSTATE_ABSENT)
3541             return FALSE;
3542     }
3543
3544     return TRUE;
3545 }
3546
3547 /*
3548  * 99% of the work done here is only done for
3549  * advertised installs. However this is where the
3550  * Icon table is processed and written out
3551  * so that is what I am going to do here.
3552  */
3553 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
3554 {
3555     UINT rc;
3556     HKEY hukey=0;
3557     HKEY hudkey=0;
3558
3559     /* FIXME: also need to publish if the product is in advertise mode */
3560     if (!msi_check_publish(package))
3561         return ERROR_SUCCESS;
3562
3563     if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3564     {
3565         rc = MSIREG_OpenLocalClassesProductKey(package->ProductCode, &hukey, TRUE);
3566         if (rc != ERROR_SUCCESS)
3567             goto end;
3568
3569         rc = MSIREG_OpenLocalUserDataProductKey(package->ProductCode, &hudkey, TRUE);
3570         if (rc != ERROR_SUCCESS)
3571             goto end;
3572     }
3573     else
3574     {
3575         rc = MSIREG_OpenUserProductsKey(package->ProductCode, &hukey, TRUE);
3576         if (rc != ERROR_SUCCESS)
3577             goto end;
3578
3579         rc = MSIREG_OpenUserDataProductKey(package->ProductCode, &hudkey, TRUE);
3580         if (rc != ERROR_SUCCESS)
3581             goto end;
3582     }
3583
3584     rc = msi_publish_upgrade_code(package);
3585     if (rc != ERROR_SUCCESS)
3586         goto end;
3587
3588     rc = msi_publish_product_properties(package, hukey);
3589     if (rc != ERROR_SUCCESS)
3590         goto end;
3591
3592     rc = msi_publish_sourcelist(package, hukey);
3593     if (rc != ERROR_SUCCESS)
3594         goto end;
3595
3596     rc = msi_publish_icons(package);
3597
3598 end:
3599     RegCloseKey(hukey);
3600     RegCloseKey(hudkey);
3601
3602     return rc;
3603 }
3604
3605 static UINT ITERATE_WriteIniValues(MSIRECORD *row, LPVOID param)
3606 {
3607     MSIPACKAGE *package = (MSIPACKAGE*)param;
3608     LPCWSTR component,section,key,value,identifier,filename,dirproperty;
3609     LPWSTR deformated_section, deformated_key, deformated_value;
3610     LPWSTR folder, fullname = NULL;
3611     MSIRECORD * uirow;
3612     INT action;
3613     MSICOMPONENT *comp;
3614     static const WCHAR szWindowsFolder[] =
3615           {'W','i','n','d','o','w','s','F','o','l','d','e','r',0};
3616
3617     component = MSI_RecordGetString(row, 8);
3618     comp = get_loaded_component(package,component);
3619
3620     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL))
3621     {
3622         TRACE("Skipping ini file due to disabled component %s\n",
3623                         debugstr_w(component));
3624
3625         comp->Action = comp->Installed;
3626
3627         return ERROR_SUCCESS;
3628     }
3629
3630     comp->Action = INSTALLSTATE_LOCAL;
3631
3632     identifier = MSI_RecordGetString(row,1);
3633     filename = MSI_RecordGetString(row,2);
3634     dirproperty = MSI_RecordGetString(row,3);
3635     section = MSI_RecordGetString(row,4);
3636     key = MSI_RecordGetString(row,5);
3637     value = MSI_RecordGetString(row,6);
3638     action = MSI_RecordGetInteger(row,7);
3639
3640     deformat_string(package,section,&deformated_section);
3641     deformat_string(package,key,&deformated_key);
3642     deformat_string(package,value,&deformated_value);
3643
3644     if (dirproperty)
3645     {
3646         folder = resolve_folder(package, dirproperty, FALSE, FALSE, TRUE, NULL);
3647         if (!folder)
3648             folder = msi_dup_property( package, dirproperty );
3649     }
3650     else
3651         folder = msi_dup_property( package, szWindowsFolder );
3652
3653     if (!folder)
3654     {
3655         ERR("Unable to resolve folder! (%s)\n",debugstr_w(dirproperty));
3656         goto cleanup;
3657     }
3658
3659     fullname = build_directory_name(2, folder, filename);
3660
3661     if (action == 0)
3662     {
3663         TRACE("Adding value %s to section %s in %s\n",
3664                 debugstr_w(deformated_key), debugstr_w(deformated_section),
3665                 debugstr_w(fullname));
3666         WritePrivateProfileStringW(deformated_section, deformated_key,
3667                                    deformated_value, fullname);
3668     }
3669     else if (action == 1)
3670     {
3671         WCHAR returned[10];
3672         GetPrivateProfileStringW(deformated_section, deformated_key, NULL,
3673                                  returned, 10, fullname);
3674         if (returned[0] == 0)
3675         {
3676             TRACE("Adding value %s to section %s in %s\n",
3677                     debugstr_w(deformated_key), debugstr_w(deformated_section),
3678                     debugstr_w(fullname));
3679
3680             WritePrivateProfileStringW(deformated_section, deformated_key,
3681                                        deformated_value, fullname);
3682         }
3683     }
3684     else if (action == 3)
3685         FIXME("Append to existing section not yet implemented\n");
3686
3687     uirow = MSI_CreateRecord(4);
3688     MSI_RecordSetStringW(uirow,1,identifier);
3689     MSI_RecordSetStringW(uirow,2,deformated_section);
3690     MSI_RecordSetStringW(uirow,3,deformated_key);
3691     MSI_RecordSetStringW(uirow,4,deformated_value);
3692     ui_actiondata(package,szWriteIniValues,uirow);
3693     msiobj_release( &uirow->hdr );
3694 cleanup:
3695     msi_free(fullname);
3696     msi_free(folder);
3697     msi_free(deformated_key);
3698     msi_free(deformated_value);
3699     msi_free(deformated_section);
3700     return ERROR_SUCCESS;
3701 }
3702
3703 static UINT ACTION_WriteIniValues(MSIPACKAGE *package)
3704 {
3705     UINT rc;
3706     MSIQUERY * view;
3707     static const WCHAR ExecSeqQuery[] =
3708         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3709          '`','I','n','i','F','i','l','e','`',0};
3710
3711     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3712     if (rc != ERROR_SUCCESS)
3713     {
3714         TRACE("no IniFile table\n");
3715         return ERROR_SUCCESS;
3716     }
3717
3718     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteIniValues, package);
3719     msiobj_release(&view->hdr);
3720     return rc;
3721 }
3722
3723 static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
3724 {
3725     MSIPACKAGE *package = (MSIPACKAGE*)param;
3726     LPCWSTR filename;
3727     LPWSTR FullName;
3728     MSIFILE *file;
3729     DWORD len;
3730     static const WCHAR ExeStr[] =
3731         {'r','e','g','s','v','r','3','2','.','e','x','e',' ','\"',0};
3732     static const WCHAR close[] =  {'\"',0};
3733     STARTUPINFOW si;
3734     PROCESS_INFORMATION info;
3735     BOOL brc;
3736     MSIRECORD *uirow;
3737     LPWSTR uipath, p;
3738
3739     memset(&si,0,sizeof(STARTUPINFOW));
3740
3741     filename = MSI_RecordGetString(row,1);
3742     file = get_loaded_file( package, filename );
3743
3744     if (!file)
3745     {
3746         ERR("Unable to find file id %s\n",debugstr_w(filename));
3747         return ERROR_SUCCESS;
3748     }
3749
3750     len = strlenW(ExeStr) + strlenW( file->TargetPath ) + 2;
3751
3752     FullName = msi_alloc(len*sizeof(WCHAR));
3753     strcpyW(FullName,ExeStr);
3754     strcatW( FullName, file->TargetPath );
3755     strcatW(FullName,close);
3756
3757     TRACE("Registering %s\n",debugstr_w(FullName));
3758     brc = CreateProcessW(NULL, FullName, NULL, NULL, FALSE, 0, NULL, c_colon,
3759                     &si, &info);
3760
3761     if (brc)
3762         msi_dialog_check_messages(info.hProcess);
3763
3764     msi_free(FullName);
3765
3766     /* the UI chunk */
3767     uirow = MSI_CreateRecord( 2 );
3768     uipath = strdupW( file->TargetPath );
3769     p = strrchrW(uipath,'\\');
3770     if (p)
3771         p[0]=0;
3772     MSI_RecordSetStringW( uirow, 1, &p[1] );
3773     MSI_RecordSetStringW( uirow, 2, uipath);
3774     ui_actiondata( package, szSelfRegModules, uirow);
3775     msiobj_release( &uirow->hdr );
3776     msi_free( uipath );
3777     /* FIXME: call ui_progress? */
3778
3779     return ERROR_SUCCESS;
3780 }
3781
3782 static UINT ACTION_SelfRegModules(MSIPACKAGE *package)
3783 {
3784     UINT rc;
3785     MSIQUERY * view;
3786     static const WCHAR ExecSeqQuery[] =
3787         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
3788          '`','S','e','l','f','R','e','g','`',0};
3789
3790     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
3791     if (rc != ERROR_SUCCESS)
3792     {
3793         TRACE("no SelfReg table\n");
3794         return ERROR_SUCCESS;
3795     }
3796
3797     MSI_IterateRecords(view, NULL, ITERATE_SelfRegModules, package);
3798     msiobj_release(&view->hdr);
3799
3800     return ERROR_SUCCESS;
3801 }
3802
3803 static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
3804 {
3805     MSIFEATURE *feature;
3806     UINT rc;
3807     HKEY hkey;
3808     HKEY userdata;
3809
3810     if (!msi_check_publish(package))
3811         return ERROR_SUCCESS;
3812
3813     if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3814     {
3815         rc = MSIREG_OpenLocalClassesFeaturesKey(package->ProductCode,
3816                                                 &hkey, TRUE);
3817         if (rc != ERROR_SUCCESS)
3818             goto end;
3819
3820         rc = MSIREG_OpenLocalUserDataFeaturesKey(package->ProductCode,
3821                                                  &userdata, TRUE);
3822         if (rc != ERROR_SUCCESS)
3823             goto end;
3824     }
3825     else
3826     {
3827         rc = MSIREG_OpenUserFeaturesKey(package->ProductCode, &hkey, TRUE);
3828         if (rc != ERROR_SUCCESS)
3829             goto end;
3830
3831         rc = MSIREG_OpenUserDataFeaturesKey(package->ProductCode,
3832                                             &userdata, TRUE);
3833         if (rc != ERROR_SUCCESS)
3834             goto end;
3835     }
3836
3837     /* here the guids are base 85 encoded */
3838     LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3839     {
3840         ComponentList *cl;
3841         LPWSTR data = NULL;
3842         GUID clsid;
3843         INT size;
3844         BOOL absent = FALSE;
3845         MSIRECORD *uirow;
3846
3847         if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ) &&
3848             !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_SOURCE ) &&
3849             !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ADVERTISED ))
3850             absent = TRUE;
3851
3852         size = 1;
3853         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3854         {
3855             size += 21;
3856         }
3857         if (feature->Feature_Parent)
3858             size += strlenW( feature->Feature_Parent )+2;
3859
3860         data = msi_alloc(size * sizeof(WCHAR));
3861
3862         data[0] = 0;
3863         LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3864         {
3865             MSICOMPONENT* component = cl->component;
3866             WCHAR buf[21];
3867
3868             buf[0] = 0;
3869             if (component->ComponentId)
3870             {
3871                 TRACE("From %s\n",debugstr_w(component->ComponentId));
3872                 CLSIDFromString(component->ComponentId, &clsid);
3873                 encode_base85_guid(&clsid,buf);
3874                 TRACE("to %s\n",debugstr_w(buf));
3875                 strcatW(data,buf);
3876             }
3877         }
3878
3879         if (feature->Feature_Parent)
3880         {
3881             static const WCHAR sep[] = {'\2',0};
3882             strcatW(data,sep);
3883             strcatW(data,feature->Feature_Parent);
3884         }
3885
3886         msi_reg_set_val_str( userdata, feature->Feature, data );
3887         msi_free(data);
3888
3889         size = 0;
3890         if (feature->Feature_Parent)
3891             size = strlenW(feature->Feature_Parent)*sizeof(WCHAR);
3892         if (!absent)
3893         {
3894             static const WCHAR emptyW[] = {0};
3895             size += sizeof(WCHAR);
3896             RegSetValueExW(hkey,feature->Feature,0,REG_SZ,
3897                            (LPBYTE)(feature->Feature_Parent ? feature->Feature_Parent : emptyW),size);
3898         }
3899         else
3900         {
3901             size += 2*sizeof(WCHAR);
3902             data = msi_alloc(size);
3903             data[0] = 0x6;
3904             data[1] = 0;
3905             if (feature->Feature_Parent)
3906                 strcpyW( &data[1], feature->Feature_Parent );
3907             RegSetValueExW(hkey,feature->Feature,0,REG_SZ,
3908                        (LPBYTE)data,size);
3909             msi_free(data);
3910         }
3911
3912         /* the UI chunk */
3913         uirow = MSI_CreateRecord( 1 );
3914         MSI_RecordSetStringW( uirow, 1, feature->Feature );
3915         ui_actiondata( package, szPublishFeatures, uirow);
3916         msiobj_release( &uirow->hdr );
3917         /* FIXME: call ui_progress? */
3918     }
3919
3920 end:
3921     RegCloseKey(hkey);
3922     RegCloseKey(userdata);
3923     return rc;
3924 }
3925
3926 static UINT msi_unpublish_feature(MSIPACKAGE *package, MSIFEATURE *feature)
3927 {
3928     UINT r;
3929     HKEY hkey;
3930
3931     TRACE("unpublishing feature %s\n", debugstr_w(feature->Feature));
3932
3933     r = MSIREG_OpenUserFeaturesKey(package->ProductCode, &hkey, FALSE);
3934     if (r == ERROR_SUCCESS)
3935     {
3936         RegDeleteValueW(hkey, feature->Feature);
3937         RegCloseKey(hkey);
3938     }
3939
3940     r = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, &hkey, FALSE);
3941     if (r == ERROR_SUCCESS)
3942     {
3943         RegDeleteValueW(hkey, feature->Feature);
3944         RegCloseKey(hkey);
3945     }
3946
3947     return ERROR_SUCCESS;
3948 }
3949
3950 static UINT ACTION_UnpublishFeatures(MSIPACKAGE *package)
3951 {
3952     MSIFEATURE *feature;
3953
3954     if (!msi_check_unpublish(package))
3955         return ERROR_SUCCESS;
3956
3957     LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
3958     {
3959         msi_unpublish_feature(package, feature);
3960     }
3961
3962     return ERROR_SUCCESS;
3963 }
3964
3965 static UINT msi_get_local_package_name( LPWSTR path )
3966 {
3967     static const WCHAR szInstaller[] = {
3968         '\\','I','n','s','t','a','l','l','e','r','\\',0};
3969     static const WCHAR fmt[] = { '%','x','.','m','s','i',0};
3970     DWORD time, len, i;
3971     HANDLE handle;
3972
3973     time = GetTickCount();
3974     GetWindowsDirectoryW( path, MAX_PATH );
3975     lstrcatW( path, szInstaller );
3976     CreateDirectoryW( path, NULL );
3977
3978     len = lstrlenW(path);
3979     for (i=0; i<0x10000; i++)
3980     {
3981         snprintfW( &path[len], MAX_PATH - len, fmt, (time+i)&0xffff );
3982         handle = CreateFileW( path, GENERIC_WRITE, 0, NULL,
3983                               CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
3984         if (handle != INVALID_HANDLE_VALUE)
3985         {
3986             CloseHandle(handle);
3987             break;
3988         }
3989         if (GetLastError() != ERROR_FILE_EXISTS &&
3990             GetLastError() != ERROR_SHARING_VIOLATION)
3991             return ERROR_FUNCTION_FAILED;
3992     }
3993
3994     return ERROR_SUCCESS;
3995 }
3996
3997 static UINT msi_make_package_local( MSIPACKAGE *package, HKEY hkey )
3998 {
3999     WCHAR packagefile[MAX_PATH];
4000     UINT r;
4001
4002     r = msi_get_local_package_name( packagefile );
4003     if (r != ERROR_SUCCESS)
4004         return r;
4005
4006     TRACE("Copying to local package %s\n",debugstr_w(packagefile));
4007
4008     r = CopyFileW( package->db->path, packagefile, FALSE);
4009
4010     if (!r)
4011     {
4012         ERR("Unable to copy package (%s -> %s) (error %d)\n",
4013             debugstr_w(package->db->path), debugstr_w(packagefile), GetLastError());
4014         return ERROR_FUNCTION_FAILED;
4015     }
4016
4017     msi_reg_set_val_str( hkey, INSTALLPROPERTY_LOCALPACKAGEW, packagefile );
4018
4019     return ERROR_SUCCESS;
4020 }
4021
4022 static UINT msi_publish_install_properties(MSIPACKAGE *package, HKEY hkey)
4023 {
4024     LPWSTR prop, val, key;
4025     SYSTEMTIME systime;
4026     DWORD size, langid;
4027     WCHAR date[9];
4028     LPWSTR buffer;
4029
4030     static const WCHAR date_fmt[] = {'%','i','%','0','2','i','%','0','2','i',0};
4031     static const WCHAR szWindowsInstaller[] =
4032         {'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
4033     static const WCHAR modpath_fmt[] =
4034         {'M','s','i','E','x','e','c','.','e','x','e',' ',
4035          '/','I','[','P','r','o','d','u','c','t','C','o','d','e',']',0};
4036     static const WCHAR szModifyPath[] =
4037         {'M','o','d','i','f','y','P','a','t','h',0};
4038     static const WCHAR szUninstallString[] =
4039         {'U','n','i','n','s','t','a','l','l','S','t','r','i','n','g',0};
4040     static const WCHAR szEstimatedSize[] =
4041         {'E','s','t','i','m','a','t','e','d','S','i','z','e',0};
4042     static const WCHAR szProductLanguage[] =
4043         {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
4044     static const WCHAR szProductVersion[] =
4045         {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
4046     static const WCHAR szProductName[] =
4047         {'P','r','o','d','u','c','t','N','a','m','e',0};
4048     static const WCHAR szDisplayName[] =
4049         {'D','i','s','p','l','a','y','N','a','m','e',0};
4050     static const WCHAR szDisplayVersion[] =
4051         {'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0};
4052     static const WCHAR szManufacturer[] =
4053         {'M','a','n','u','f','a','c','t','u','r','e','r',0};
4054
4055     static const LPCSTR propval[] = {
4056         "ARPAUTHORIZEDCDFPREFIX", "AuthorizedCDFPrefix",
4057         "ARPCONTACT",             "Contact",
4058         "ARPCOMMENTS",            "Comments",
4059         "ProductName",            "DisplayName",
4060         "ProductVersion",         "DisplayVersion",
4061         "ARPHELPLINK",            "HelpLink",
4062         "ARPHELPTELEPHONE",       "HelpTelephone",
4063         "ARPINSTALLLOCATION",     "InstallLocation",
4064         "SourceDir",              "InstallSource",
4065         "Manufacturer",           "Publisher",
4066         "ARPREADME",              "Readme",
4067         "ARPSIZE",                "Size",
4068         "ARPURLINFOABOUT",        "URLInfoAbout",
4069         "ARPURLUPDATEINFO",       "URLUpdateInfo",
4070         NULL,
4071     };
4072     const LPCSTR *p = propval;
4073
4074     while (*p)
4075     {
4076         prop = strdupAtoW(*p++);
4077         key = strdupAtoW(*p++);
4078         val = msi_dup_property(package, prop);
4079         msi_reg_set_val_str(hkey, key, val);
4080         msi_free(val);
4081         msi_free(key);
4082         msi_free(prop);
4083     }
4084
4085     msi_reg_set_val_dword(hkey, szWindowsInstaller, 1);
4086
4087     size = deformat_string(package, modpath_fmt, &buffer);
4088     RegSetValueExW(hkey, szModifyPath, 0, REG_EXPAND_SZ, (LPBYTE)buffer, size);
4089     RegSetValueExW(hkey, szUninstallString, 0, REG_EXPAND_SZ, (LPBYTE)buffer, size);
4090     msi_free(buffer);
4091
4092     /* FIXME: Write real Estimated Size when we have it */
4093     msi_reg_set_val_dword(hkey, szEstimatedSize, 0);
4094
4095     buffer = msi_dup_property(package, szProductName);
4096     msi_reg_set_val_str(hkey, szDisplayName, buffer);
4097     msi_free(buffer);
4098
4099     buffer = msi_dup_property(package, cszSourceDir);
4100     msi_reg_set_val_str(hkey, INSTALLPROPERTY_INSTALLSOURCEW, buffer);
4101     msi_free(buffer);
4102
4103     buffer = msi_dup_property(package, szManufacturer);
4104     msi_reg_set_val_str(hkey, INSTALLPROPERTY_PUBLISHERW, buffer);
4105     msi_free(buffer);
4106
4107     GetLocalTime(&systime);
4108     sprintfW(date, date_fmt, systime.wYear, systime.wMonth, systime.wDay);
4109     msi_reg_set_val_str(hkey, INSTALLPROPERTY_INSTALLDATEW, date);
4110
4111     langid = msi_get_property_int(package, szProductLanguage, 0);
4112     msi_reg_set_val_dword(hkey, INSTALLPROPERTY_LANGUAGEW, langid);
4113
4114     buffer = msi_dup_property(package, szProductVersion);
4115     msi_reg_set_val_str(hkey, szDisplayVersion, buffer);
4116     if (buffer)
4117     {
4118         DWORD verdword = msi_version_str_to_dword(buffer);
4119
4120         msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONW, verdword);
4121         msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword >> 24);
4122         msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword >> 16) & 0xFF);
4123         msi_free(buffer);
4124     }
4125
4126     return ERROR_SUCCESS;
4127 }
4128
4129 static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
4130 {
4131     WCHAR squashed_pc[SQUISH_GUID_SIZE];
4132     LPWSTR upgrade_code;
4133     HKEY hkey, props;
4134     HKEY upgrade;
4135     UINT rc;
4136
4137     static const WCHAR szUpgradeCode[] = {
4138         'U','p','g','r','a','d','e','C','o','d','e',0};
4139
4140     /* FIXME: also need to publish if the product is in advertise mode */
4141     if (!msi_check_publish(package))
4142         return ERROR_SUCCESS;
4143
4144     rc = MSIREG_OpenUninstallKey(package->ProductCode, &hkey, TRUE);
4145     if (rc != ERROR_SUCCESS)
4146         return rc;
4147
4148     if (package->Context == MSIINSTALLCONTEXT_MACHINE)
4149     {
4150         rc = MSIREG_OpenLocalSystemInstallProps(package->ProductCode, &props, TRUE);
4151         if (rc != ERROR_SUCCESS)
4152             goto done;
4153     }
4154     else
4155     {
4156         rc = MSIREG_OpenCurrentUserInstallProps(package->ProductCode, &props, TRUE);
4157         if (rc != ERROR_SUCCESS)
4158             goto done;
4159     }
4160
4161     msi_make_package_local(package, props);
4162
4163     rc = msi_publish_install_properties(package, hkey);
4164     if (rc != ERROR_SUCCESS)
4165         goto done;
4166
4167     rc = msi_publish_install_properties(package, props);
4168     if (rc != ERROR_SUCCESS)
4169         goto done;
4170
4171     upgrade_code = msi_dup_property(package, szUpgradeCode);
4172     if (upgrade_code)
4173     {
4174         MSIREG_OpenUpgradeCodesKey(upgrade_code, &upgrade, TRUE);
4175         squash_guid(package->ProductCode, squashed_pc);
4176         msi_reg_set_val_str(upgrade, squashed_pc, NULL);
4177         RegCloseKey(upgrade);
4178         msi_free(upgrade_code);
4179     }
4180
4181 done:
4182     RegCloseKey(hkey);
4183
4184     return ERROR_SUCCESS;
4185 }
4186
4187 static UINT ACTION_InstallExecute(MSIPACKAGE *package)
4188 {
4189     return execute_script(package,INSTALL_SCRIPT);
4190 }
4191
4192 static UINT msi_unpublish_product(MSIPACKAGE *package)
4193 {
4194     LPWSTR upgrade;
4195     LPWSTR remove = NULL;
4196     LPWSTR *features = NULL;
4197     BOOL full_uninstall = TRUE;
4198     MSIFEATURE *feature;
4199
4200     static const WCHAR szRemove[] = {'R','E','M','O','V','E',0};
4201     static const WCHAR szAll[] = {'A','L','L',0};
4202     static const WCHAR szUpgradeCode[] =
4203         {'U','p','g','r','a','d','e','C','o','d','e',0};
4204
4205     remove = msi_dup_property(package, szRemove);
4206     if (!remove)
4207         return ERROR_SUCCESS;
4208
4209     features = msi_split_string(remove, ',');
4210     if (!features)
4211     {
4212         msi_free(remove);
4213         ERR("REMOVE feature list is empty!\n");
4214         return ERROR_FUNCTION_FAILED;
4215     }
4216
4217     if (!lstrcmpW(features[0], szAll))
4218         full_uninstall = TRUE;
4219     else
4220     {
4221         LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4222         {
4223             if (feature->Action != INSTALLSTATE_ABSENT)
4224                 full_uninstall = FALSE;
4225         }
4226     }
4227
4228     if (!full_uninstall)
4229         goto done;
4230
4231     MSIREG_DeleteProductKey(package->ProductCode);
4232     MSIREG_DeleteUserProductKey(package->ProductCode);
4233     MSIREG_DeleteUserDataProductKey(package->ProductCode);
4234     MSIREG_DeleteUserFeaturesKey(package->ProductCode);
4235     MSIREG_DeleteUninstallKey(package->ProductCode);
4236
4237     upgrade = msi_dup_property(package, szUpgradeCode);
4238     if (upgrade)
4239     {
4240         MSIREG_DeleteUserUpgradeCodesKey(upgrade);
4241         msi_free(upgrade);
4242     }
4243
4244 done:
4245     msi_free(remove);
4246     msi_free(features);
4247     return ERROR_SUCCESS;
4248 }
4249
4250 static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
4251 {
4252     UINT rc;
4253
4254     rc = msi_unpublish_product(package);
4255     if (rc != ERROR_SUCCESS)
4256         return rc;
4257
4258     /* turn off scheduling */
4259     package->script->CurrentlyScripting= FALSE;
4260
4261     /* first do the same as an InstallExecute */
4262     rc = ACTION_InstallExecute(package);
4263     if (rc != ERROR_SUCCESS)
4264         return rc;
4265
4266     /* then handle Commit Actions */
4267     rc = execute_script(package,COMMIT_SCRIPT);
4268
4269     return rc;
4270 }
4271
4272 UINT ACTION_ForceReboot(MSIPACKAGE *package)
4273 {
4274     static const WCHAR RunOnce[] = {
4275     'S','o','f','t','w','a','r','e','\\',
4276     'M','i','c','r','o','s','o','f','t','\\',
4277     'W','i','n','d','o','w','s','\\',
4278     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
4279     'R','u','n','O','n','c','e',0};
4280     static const WCHAR InstallRunOnce[] = {
4281     'S','o','f','t','w','a','r','e','\\',
4282     'M','i','c','r','o','s','o','f','t','\\',
4283     'W','i','n','d','o','w','s','\\',
4284     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
4285     'I','n','s','t','a','l','l','e','r','\\',
4286     'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0};
4287
4288     static const WCHAR msiexec_fmt[] = {
4289     '%','s',
4290     '\\','M','s','i','E','x','e','c','.','e','x','e',' ','/','@',' ',
4291     '\"','%','s','\"',0};
4292     static const WCHAR install_fmt[] = {
4293     '/','I',' ','\"','%','s','\"',' ',
4294     'A','F','T','E','R','R','E','B','O','O','T','=','1',' ',
4295     'R','U','N','O','N','C','E','E','N','T','R','Y','=','\"','%','s','\"',0};
4296     WCHAR buffer[256], sysdir[MAX_PATH];
4297     HKEY hkey;
4298     WCHAR squished_pc[100];
4299
4300     squash_guid(package->ProductCode,squished_pc);
4301
4302     GetSystemDirectoryW(sysdir, sizeof(sysdir)/sizeof(sysdir[0]));
4303     RegCreateKeyW(HKEY_LOCAL_MACHINE,RunOnce,&hkey);
4304     snprintfW(buffer,sizeof(buffer)/sizeof(buffer[0]),msiexec_fmt,sysdir,
4305      squished_pc);
4306
4307     msi_reg_set_val_str( hkey, squished_pc, buffer );
4308     RegCloseKey(hkey);
4309
4310     TRACE("Reboot command %s\n",debugstr_w(buffer));
4311
4312     RegCreateKeyW(HKEY_LOCAL_MACHINE,InstallRunOnce,&hkey);
4313     sprintfW(buffer,install_fmt,package->ProductCode,squished_pc);
4314
4315     msi_reg_set_val_str( hkey, squished_pc, buffer );
4316     RegCloseKey(hkey);
4317
4318     return ERROR_INSTALL_SUSPEND;
4319 }
4320
4321 static UINT ACTION_ResolveSource(MSIPACKAGE* package)
4322 {
4323     DWORD attrib;
4324     UINT rc;
4325
4326     /*
4327      * We are currently doing what should be done here in the top level Install
4328      * however for Administrative and uninstalls this step will be needed
4329      */
4330     if (!package->PackagePath)
4331         return ERROR_SUCCESS;
4332
4333     msi_set_sourcedir_props(package, TRUE);
4334
4335     attrib = GetFileAttributesW(package->db->path);
4336     if (attrib == INVALID_FILE_ATTRIBUTES)
4337     {
4338         LPWSTR prompt;
4339         LPWSTR msg;
4340         DWORD size = 0;
4341
4342         rc = MsiSourceListGetInfoW(package->ProductCode, NULL,
4343                 package->Context, MSICODE_PRODUCT,
4344                 INSTALLPROPERTY_DISKPROMPTW,NULL,&size);
4345         if (rc == ERROR_MORE_DATA)
4346         {
4347             prompt = msi_alloc(size * sizeof(WCHAR));
4348             MsiSourceListGetInfoW(package->ProductCode, NULL,
4349                     package->Context, MSICODE_PRODUCT,
4350                     INSTALLPROPERTY_DISKPROMPTW,prompt,&size);
4351         }
4352         else
4353             prompt = strdupW(package->db->path);
4354
4355         msg = generate_error_string(package,1302,1,prompt);
4356         while(attrib == INVALID_FILE_ATTRIBUTES)
4357         {
4358             rc = MessageBoxW(NULL,msg,NULL,MB_OKCANCEL);
4359             if (rc == IDCANCEL)
4360             {
4361                 rc = ERROR_INSTALL_USEREXIT;
4362                 break;
4363             }
4364             attrib = GetFileAttributesW(package->db->path);
4365         }
4366         msi_free(prompt);
4367         rc = ERROR_SUCCESS;
4368     }
4369     else
4370         return ERROR_SUCCESS;
4371
4372     return rc;
4373 }
4374
4375 static UINT ACTION_RegisterUser(MSIPACKAGE *package)
4376 {
4377     HKEY hkey=0;
4378     LPWSTR buffer;
4379     LPWSTR productid;
4380     UINT rc,i;
4381
4382     static const WCHAR szPropKeys[][80] =
4383     {
4384         {'P','r','o','d','u','c','t','I','D',0},
4385         {'U','S','E','R','N','A','M','E',0},
4386         {'C','O','M','P','A','N','Y','N','A','M','E',0},
4387         {0},
4388     };
4389
4390     static const WCHAR szRegKeys[][80] =
4391     {
4392         {'P','r','o','d','u','c','t','I','D',0},
4393         {'R','e','g','O','w','n','e','r',0},
4394         {'R','e','g','C','o','m','p','a','n','y',0},
4395         {0},
4396     };
4397
4398     if (msi_check_unpublish(package))
4399     {
4400         MSIREG_DeleteUserDataProductKey(package->ProductCode);
4401         return ERROR_SUCCESS;
4402     }
4403
4404     productid = msi_dup_property( package, INSTALLPROPERTY_PRODUCTIDW );
4405     if (!productid)
4406         return ERROR_SUCCESS;
4407
4408     if (package->Context == MSIINSTALLCONTEXT_MACHINE)
4409         rc = MSIREG_OpenLocalSystemInstallProps(package->ProductCode, &hkey, TRUE);
4410     else
4411         rc = MSIREG_OpenCurrentUserInstallProps(package->ProductCode, &hkey, TRUE);
4412
4413     if (rc != ERROR_SUCCESS)
4414         goto end;
4415
4416     for( i = 0; szPropKeys[i][0]; i++ )
4417     {
4418         buffer = msi_dup_property( package, szPropKeys[i] );
4419         msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
4420         msi_free( buffer );
4421     }
4422
4423 end:
4424     msi_free(productid);
4425     RegCloseKey(hkey);
4426
4427     /* FIXME: call ui_actiondata */
4428
4429     return rc;
4430 }
4431
4432
4433 static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
4434 {
4435     UINT rc;
4436
4437     package->script->InWhatSequence |= SEQUENCE_EXEC;
4438     rc = ACTION_ProcessExecSequence(package,FALSE);
4439     return rc;
4440 }
4441
4442
4443 static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
4444 {
4445     MSIPACKAGE *package = (MSIPACKAGE*)param;
4446     LPCWSTR compgroupid=NULL;
4447     LPCWSTR feature=NULL;
4448     LPCWSTR text = NULL;
4449     LPCWSTR qualifier = NULL;
4450     LPCWSTR component = NULL;
4451     LPWSTR advertise = NULL;
4452     LPWSTR output = NULL;
4453     HKEY hkey;
4454     UINT rc = ERROR_SUCCESS;
4455     MSICOMPONENT *comp;
4456     DWORD sz = 0;
4457     MSIRECORD *uirow;
4458
4459     component = MSI_RecordGetString(rec,3);
4460     comp = get_loaded_component(package,component);
4461
4462     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ) &&
4463        !ACTION_VerifyComponentForAction( comp, INSTALLSTATE_SOURCE ) &&
4464        !ACTION_VerifyComponentForAction( comp, INSTALLSTATE_ADVERTISED ))
4465     {
4466         TRACE("Skipping: Component %s not scheduled for install\n",
4467                         debugstr_w(component));
4468
4469         return ERROR_SUCCESS;
4470     }
4471
4472     compgroupid = MSI_RecordGetString(rec,1);
4473     qualifier = MSI_RecordGetString(rec,2);
4474
4475     rc = MSIREG_OpenUserComponentsKey(compgroupid, &hkey, TRUE);
4476     if (rc != ERROR_SUCCESS)
4477         goto end;
4478
4479     text = MSI_RecordGetString(rec,4);
4480     feature = MSI_RecordGetString(rec,5);
4481
4482     advertise = create_component_advertise_string(package, comp, feature);
4483
4484     sz = strlenW(advertise);
4485
4486     if (text)
4487         sz += lstrlenW(text);
4488
4489     sz+=3;
4490     sz *= sizeof(WCHAR);
4491
4492     output = msi_alloc_zero(sz);
4493     strcpyW(output,advertise);
4494     msi_free(advertise);
4495
4496     if (text)
4497         strcatW(output,text);
4498
4499     msi_reg_set_val_multi_str( hkey, qualifier, output );
4500
4501 end:
4502     RegCloseKey(hkey);
4503     msi_free(output);
4504
4505     /* the UI chunk */
4506     uirow = MSI_CreateRecord( 2 );
4507     MSI_RecordSetStringW( uirow, 1, compgroupid );
4508     MSI_RecordSetStringW( uirow, 2, qualifier);
4509     ui_actiondata( package, szPublishComponents, uirow);
4510     msiobj_release( &uirow->hdr );
4511     /* FIXME: call ui_progress? */
4512
4513     return rc;
4514 }
4515
4516 /*
4517  * At present I am ignorning the advertised components part of this and only
4518  * focusing on the qualified component sets
4519  */
4520 static UINT ACTION_PublishComponents(MSIPACKAGE *package)
4521 {
4522     UINT rc;
4523     MSIQUERY * view;
4524     static const WCHAR ExecSeqQuery[] =
4525         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4526          '`','P','u','b','l','i','s','h',
4527          'C','o','m','p','o','n','e','n','t','`',0};
4528
4529     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4530     if (rc != ERROR_SUCCESS)
4531         return ERROR_SUCCESS;
4532
4533     rc = MSI_IterateRecords(view, NULL, ITERATE_PublishComponent, package);
4534     msiobj_release(&view->hdr);
4535
4536     return rc;
4537 }
4538
4539 static UINT ITERATE_InstallService(MSIRECORD *rec, LPVOID param)
4540 {
4541     MSIPACKAGE *package = (MSIPACKAGE*)param;
4542     MSIRECORD *row;
4543     MSIFILE *file;
4544     SC_HANDLE hscm, service = NULL;
4545     LPCWSTR comp, depends, pass;
4546     LPWSTR name = NULL, disp = NULL;
4547     LPCWSTR load_order, serv_name, key;
4548     DWORD serv_type, start_type;
4549     DWORD err_control;
4550
4551     static const WCHAR query[] =
4552         {'S','E','L','E','C','T',' ','*',' ','F','R', 'O','M',' ',
4553          '`','C','o','m','p','o','n','e','n','t','`',' ',
4554          'W','H','E','R','E',' ',
4555          '`','C','o','m','p','o','n','e','n','t','`',' ',
4556          '=','\'','%','s','\'',0};
4557
4558     hscm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, GENERIC_WRITE);
4559     if (!hscm)
4560     {
4561         ERR("Failed to open the SC Manager!\n");
4562         goto done;
4563     }
4564
4565     start_type = MSI_RecordGetInteger(rec, 5);
4566     if (start_type == SERVICE_BOOT_START || start_type == SERVICE_SYSTEM_START)
4567         goto done;
4568
4569     depends = MSI_RecordGetString(rec, 8);
4570     if (depends && *depends)
4571         FIXME("Dependency list unhandled!\n");
4572
4573     deformat_string(package, MSI_RecordGetString(rec, 2), &name);
4574     deformat_string(package, MSI_RecordGetString(rec, 3), &disp);
4575     serv_type = MSI_RecordGetInteger(rec, 4);
4576     err_control = MSI_RecordGetInteger(rec, 6);
4577     load_order = MSI_RecordGetString(rec, 7);
4578     serv_name = MSI_RecordGetString(rec, 9);
4579     pass = MSI_RecordGetString(rec, 10);
4580     comp = MSI_RecordGetString(rec, 12);
4581
4582     /* fetch the service path */
4583     row = MSI_QueryGetRecord(package->db, query, comp);
4584     if (!row)
4585     {
4586         ERR("Control query failed!\n");
4587         goto done;
4588     }
4589
4590     key = MSI_RecordGetString(row, 6);
4591
4592     file = get_loaded_file(package, key);
4593     msiobj_release(&row->hdr);
4594     if (!file)
4595     {
4596         ERR("Failed to load the service file\n");
4597         goto done;
4598     }
4599
4600     service = CreateServiceW(hscm, name, disp, GENERIC_ALL, serv_type,
4601                              start_type, err_control, file->TargetPath,
4602                              load_order, NULL, NULL, serv_name, pass);
4603     if (!service)
4604     {
4605         if (GetLastError() != ERROR_SERVICE_EXISTS)
4606             ERR("Failed to create service %s: %d\n", debugstr_w(name), GetLastError());
4607     }
4608
4609 done:
4610     CloseServiceHandle(service);
4611     CloseServiceHandle(hscm);
4612     msi_free(name);
4613     msi_free(disp);
4614
4615     return ERROR_SUCCESS;
4616 }
4617
4618 static UINT ACTION_InstallServices( MSIPACKAGE *package )
4619 {
4620     UINT rc;
4621     MSIQUERY * view;
4622     static const WCHAR ExecSeqQuery[] =
4623         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4624          'S','e','r','v','i','c','e','I','n','s','t','a','l','l',0};
4625
4626     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
4627     if (rc != ERROR_SUCCESS)
4628         return ERROR_SUCCESS;
4629
4630     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallService, package);
4631     msiobj_release(&view->hdr);
4632
4633     return rc;
4634 }
4635
4636 /* converts arg1[~]arg2[~]arg3 to a list of ptrs to the strings */
4637 static LPCWSTR *msi_service_args_to_vector(LPWSTR args, DWORD *numargs)
4638 {
4639     LPCWSTR *vector, *temp_vector;
4640     LPWSTR p, q;
4641     DWORD sep_len;
4642
4643     static const WCHAR separator[] = {'[','~',']',0};
4644
4645     *numargs = 0;
4646     sep_len = sizeof(separator) / sizeof(WCHAR) - 1;
4647
4648     if (!args)
4649         return NULL;
4650
4651     vector = msi_alloc(sizeof(LPWSTR));
4652     if (!vector)
4653         return NULL;
4654
4655     p = args;
4656     do
4657     {
4658         (*numargs)++;
4659         vector[*numargs - 1] = p;
4660
4661         if ((q = strstrW(p, separator)))
4662         {
4663             *q = '\0';
4664
4665             temp_vector = msi_realloc(vector, (*numargs + 1) * sizeof(LPWSTR));
4666             if (!temp_vector)
4667             {
4668                 msi_free(vector);
4669                 return NULL;
4670             }
4671             vector = temp_vector;
4672
4673             p = q + sep_len;
4674         }
4675     } while (q);
4676
4677     return vector;
4678 }
4679
4680 static UINT ITERATE_StartService(MSIRECORD *rec, LPVOID param)
4681 {
4682     MSIPACKAGE *package = (MSIPACKAGE *)param;
4683     MSICOMPONENT *comp;
4684     SC_HANDLE scm, service = NULL;
4685     LPCWSTR name, *vector = NULL;
4686     LPWSTR args;
4687     DWORD event, numargs;
4688     UINT r = ERROR_FUNCTION_FAILED;
4689
4690     comp = get_loaded_component(package, MSI_RecordGetString(rec, 6));
4691     if (!comp || comp->Action == INSTALLSTATE_UNKNOWN || comp->Action == INSTALLSTATE_ABSENT)
4692         return ERROR_SUCCESS;
4693
4694     name = MSI_RecordGetString(rec, 2);
4695     event = MSI_RecordGetInteger(rec, 3);
4696     args = strdupW(MSI_RecordGetString(rec, 4));
4697
4698     if (!(event & msidbServiceControlEventStart))
4699         return ERROR_SUCCESS;
4700
4701     scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
4702     if (!scm)
4703     {
4704         ERR("Failed to open the service control manager\n");
4705         goto done;
4706     }
4707
4708     service = OpenServiceW(scm, name, SERVICE_START);
4709     if (!service)
4710     {
4711         ERR("Failed to open service %s\n", debugstr_w(name));
4712         goto done;
4713     }
4714
4715     vector = msi_service_args_to_vector(args, &numargs);
4716
4717     if (!StartServiceW(service, numargs, vector))
4718     {
4719         ERR("Failed to start service %s\n", debugstr_w(name));
4720         goto done;
4721     }
4722
4723     r = ERROR_SUCCESS;
4724
4725 done:
4726     CloseServiceHandle(service);
4727     CloseServiceHandle(scm);
4728
4729     msi_free(args);
4730     msi_free(vector);
4731     return r;
4732 }
4733
4734 static UINT ACTION_StartServices( MSIPACKAGE *package )
4735 {
4736     UINT rc;
4737     MSIQUERY *view;
4738
4739     static const WCHAR query[] = {
4740         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4741         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4742
4743     rc = MSI_DatabaseOpenViewW(package->db, query, &view);
4744     if (rc != ERROR_SUCCESS)
4745         return ERROR_SUCCESS;
4746
4747     rc = MSI_IterateRecords(view, NULL, ITERATE_StartService, package);
4748     msiobj_release(&view->hdr);
4749
4750     return rc;
4751 }
4752
4753 static BOOL stop_service_dependents(SC_HANDLE scm, SC_HANDLE service)
4754 {
4755     DWORD i, needed, count;
4756     ENUM_SERVICE_STATUSW *dependencies;
4757     SERVICE_STATUS ss;
4758     SC_HANDLE depserv;
4759
4760     if (EnumDependentServicesW(service, SERVICE_ACTIVE, NULL,
4761                                0, &needed, &count))
4762         return TRUE;
4763
4764     if (GetLastError() != ERROR_MORE_DATA)
4765         return FALSE;
4766
4767     dependencies = msi_alloc(needed);
4768     if (!dependencies)
4769         return FALSE;
4770
4771     if (!EnumDependentServicesW(service, SERVICE_ACTIVE, dependencies,
4772                                 needed, &needed, &count))
4773         goto error;
4774
4775     for (i = 0; i < count; i++)
4776     {
4777         depserv = OpenServiceW(scm, dependencies[i].lpServiceName,
4778                                SERVICE_STOP | SERVICE_QUERY_STATUS);
4779         if (!depserv)
4780             goto error;
4781
4782         if (!ControlService(depserv, SERVICE_CONTROL_STOP, &ss))
4783             goto error;
4784     }
4785
4786     return TRUE;
4787
4788 error:
4789     msi_free(dependencies);
4790     return FALSE;
4791 }
4792
4793 static UINT ITERATE_StopService(MSIRECORD *rec, LPVOID param)
4794 {
4795     MSIPACKAGE *package = (MSIPACKAGE *)param;
4796     MSICOMPONENT *comp;
4797     SERVICE_STATUS status;
4798     SERVICE_STATUS_PROCESS ssp;
4799     SC_HANDLE scm = NULL, service = NULL;
4800     LPWSTR name, args;
4801     DWORD event, needed;
4802
4803     event = MSI_RecordGetInteger(rec, 3);
4804     if (!(event & msidbServiceControlEventStop))
4805         return ERROR_SUCCESS;
4806
4807     comp = get_loaded_component(package, MSI_RecordGetString(rec, 6));
4808     if (!comp || comp->Action == INSTALLSTATE_UNKNOWN || comp->Action == INSTALLSTATE_ABSENT)
4809         return ERROR_SUCCESS;
4810
4811     deformat_string(package, MSI_RecordGetString(rec, 2), &name);
4812     deformat_string(package, MSI_RecordGetString(rec, 4), &args);
4813     args = strdupW(MSI_RecordGetString(rec, 4));
4814
4815     scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
4816     if (!scm)
4817     {
4818         WARN("Failed to open the SCM: %d\n", GetLastError());
4819         goto done;
4820     }
4821
4822     service = OpenServiceW(scm, name,
4823                            SERVICE_STOP |
4824                            SERVICE_QUERY_STATUS |
4825                            SERVICE_ENUMERATE_DEPENDENTS);
4826     if (!service)
4827     {
4828         WARN("Failed to open service (%s): %d\n",
4829               debugstr_w(name), GetLastError());
4830         goto done;
4831     }
4832
4833     if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp,
4834                               sizeof(SERVICE_STATUS_PROCESS), &needed))
4835     {
4836         WARN("Failed to query service status (%s): %d\n",
4837              debugstr_w(name), GetLastError());
4838         goto done;
4839     }
4840
4841     if (ssp.dwCurrentState == SERVICE_STOPPED)
4842         goto done;
4843
4844     stop_service_dependents(scm, service);
4845
4846     if (!ControlService(service, SERVICE_CONTROL_STOP, &status))
4847         WARN("Failed to stop service (%s): %d\n", debugstr_w(name), GetLastError());
4848
4849 done:
4850     CloseServiceHandle(service);
4851     CloseServiceHandle(scm);
4852     msi_free(name);
4853     msi_free(args);
4854
4855     return ERROR_SUCCESS;
4856 }
4857
4858 static UINT ACTION_StopServices( MSIPACKAGE *package )
4859 {
4860     UINT rc;
4861     MSIQUERY *view;
4862
4863     static const WCHAR query[] = {
4864         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
4865         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
4866
4867     rc = MSI_DatabaseOpenViewW(package->db, query, &view);
4868     if (rc != ERROR_SUCCESS)
4869         return ERROR_SUCCESS;
4870
4871     rc = MSI_IterateRecords(view, NULL, ITERATE_StopService, package);
4872     msiobj_release(&view->hdr);
4873
4874     return rc;
4875 }
4876
4877 static MSIFILE *msi_find_file( MSIPACKAGE *package, LPCWSTR filename )
4878 {
4879     MSIFILE *file;
4880
4881     LIST_FOR_EACH_ENTRY(file, &package->files, MSIFILE, entry)
4882     {
4883         if (!lstrcmpW(file->File, filename))
4884             return file;
4885     }
4886
4887     return NULL;
4888 }
4889
4890 static UINT ITERATE_InstallODBCDriver( MSIRECORD *rec, LPVOID param )
4891 {
4892     MSIPACKAGE *package = (MSIPACKAGE*)param;
4893     LPWSTR driver, driver_path, ptr;
4894     WCHAR outpath[MAX_PATH];
4895     MSIFILE *driver_file, *setup_file;
4896     LPCWSTR desc;
4897     DWORD len, usage;
4898     UINT r = ERROR_SUCCESS;
4899
4900     static const WCHAR driver_fmt[] = {
4901         'D','r','i','v','e','r','=','%','s',0};
4902     static const WCHAR setup_fmt[] = {
4903         'S','e','t','u','p','=','%','s',0};
4904     static const WCHAR usage_fmt[] = {
4905         'F','i','l','e','U','s','a','g','e','=','1',0};
4906
4907     desc = MSI_RecordGetString(rec, 3);
4908
4909     driver_file = msi_find_file(package, MSI_RecordGetString(rec, 4));
4910     setup_file = msi_find_file(package, MSI_RecordGetString(rec, 5));
4911
4912     if (!driver_file || !setup_file)
4913     {
4914         ERR("ODBC Driver entry not found!\n");
4915         return ERROR_FUNCTION_FAILED;
4916     }
4917
4918     len = lstrlenW(desc) + lstrlenW(driver_fmt) + lstrlenW(driver_file->FileName) +
4919           lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName) +
4920           lstrlenW(usage_fmt) + 1;
4921     driver = msi_alloc(len * sizeof(WCHAR));
4922     if (!driver)
4923         return ERROR_OUTOFMEMORY;
4924
4925     ptr = driver;
4926     lstrcpyW(ptr, desc);
4927     ptr += lstrlenW(ptr) + 1;
4928
4929     sprintfW(ptr, driver_fmt, driver_file->FileName);
4930     ptr += lstrlenW(ptr) + 1;
4931
4932     sprintfW(ptr, setup_fmt, setup_file->FileName);
4933     ptr += lstrlenW(ptr) + 1;
4934
4935     lstrcpyW(ptr, usage_fmt);
4936     ptr += lstrlenW(ptr) + 1;
4937     *ptr = '\0';
4938
4939     driver_path = strdupW(driver_file->TargetPath);
4940     ptr = strrchrW(driver_path, '\\');
4941     if (ptr) *ptr = '\0';
4942
4943     if (!SQLInstallDriverExW(driver, driver_path, outpath, MAX_PATH,
4944                              NULL, ODBC_INSTALL_COMPLETE, &usage))
4945     {
4946         ERR("Failed to install SQL driver!\n");
4947         r = ERROR_FUNCTION_FAILED;
4948     }
4949
4950     msi_free(driver);
4951     msi_free(driver_path);
4952
4953     return r;
4954 }
4955
4956 static UINT ITERATE_InstallODBCTranslator( MSIRECORD *rec, LPVOID param )
4957 {
4958     MSIPACKAGE *package = (MSIPACKAGE*)param;
4959     LPWSTR translator, translator_path, ptr;
4960     WCHAR outpath[MAX_PATH];
4961     MSIFILE *translator_file, *setup_file;
4962     LPCWSTR desc;
4963     DWORD len, usage;
4964     UINT r = ERROR_SUCCESS;
4965
4966     static const WCHAR translator_fmt[] = {
4967         'T','r','a','n','s','l','a','t','o','r','=','%','s',0};
4968     static const WCHAR setup_fmt[] = {
4969         'S','e','t','u','p','=','%','s',0};
4970
4971     desc = MSI_RecordGetString(rec, 3);
4972
4973     translator_file = msi_find_file(package, MSI_RecordGetString(rec, 4));
4974     setup_file = msi_find_file(package, MSI_RecordGetString(rec, 5));
4975
4976     if (!translator_file || !setup_file)
4977     {
4978         ERR("ODBC Translator entry not found!\n");
4979         return ERROR_FUNCTION_FAILED;
4980     }
4981
4982     len = lstrlenW(desc) + lstrlenW(translator_fmt) + lstrlenW(translator_file->FileName) +
4983           lstrlenW(setup_fmt) + lstrlenW(setup_file->FileName) + 1;
4984     translator = msi_alloc(len * sizeof(WCHAR));
4985     if (!translator)
4986         return ERROR_OUTOFMEMORY;
4987
4988     ptr = translator;
4989     lstrcpyW(ptr, desc);
4990     ptr += lstrlenW(ptr) + 1;
4991
4992     sprintfW(ptr, translator_fmt, translator_file->FileName);
4993     ptr += lstrlenW(ptr) + 1;
4994
4995     sprintfW(ptr, setup_fmt, setup_file->FileName);
4996     ptr += lstrlenW(ptr) + 1;
4997     *ptr = '\0';
4998
4999     translator_path = strdupW(translator_file->TargetPath);
5000     ptr = strrchrW(translator_path, '\\');
5001     if (ptr) *ptr = '\0';
5002
5003     if (!SQLInstallTranslatorExW(translator, translator_path, outpath, MAX_PATH,
5004                                  NULL, ODBC_INSTALL_COMPLETE, &usage))
5005     {
5006         ERR("Failed to install SQL translator!\n");
5007         r = ERROR_FUNCTION_FAILED;
5008     }
5009
5010     msi_free(translator);
5011     msi_free(translator_path);
5012
5013     return r;
5014 }
5015
5016 static UINT ITERATE_InstallODBCDataSource( MSIRECORD *rec, LPVOID param )
5017 {
5018     LPWSTR attrs;
5019     LPCWSTR desc, driver;
5020     WORD request = ODBC_ADD_SYS_DSN;
5021     INT registration;
5022     DWORD len;
5023     UINT r = ERROR_SUCCESS;
5024
5025     static const WCHAR attrs_fmt[] = {
5026         'D','S','N','=','%','s',0 };
5027
5028     desc = MSI_RecordGetString(rec, 3);
5029     driver = MSI_RecordGetString(rec, 4);
5030     registration = MSI_RecordGetInteger(rec, 5);
5031
5032     if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_ADD_SYS_DSN;
5033     else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_ADD_DSN;
5034
5035     len = lstrlenW(attrs_fmt) + lstrlenW(desc) + 1 + 1;
5036     attrs = msi_alloc(len * sizeof(WCHAR));
5037     if (!attrs)
5038         return ERROR_OUTOFMEMORY;
5039
5040     sprintfW(attrs, attrs_fmt, desc);
5041     attrs[len - 1] = '\0';
5042
5043     if (!SQLConfigDataSourceW(NULL, request, driver, attrs))
5044     {
5045         ERR("Failed to install SQL data source!\n");
5046         r = ERROR_FUNCTION_FAILED;
5047     }
5048
5049     msi_free(attrs);
5050
5051     return r;
5052 }
5053
5054 static UINT ACTION_InstallODBC( MSIPACKAGE *package )
5055 {
5056     UINT rc;
5057     MSIQUERY *view;
5058
5059     static const WCHAR driver_query[] = {
5060         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5061         'O','D','B','C','D','r','i','v','e','r',0 };
5062
5063     static const WCHAR translator_query[] = {
5064         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5065         'O','D','B','C','T','r','a','n','s','l','a','t','o','r',0 };
5066
5067     static const WCHAR source_query[] = {
5068         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5069         'O','D','B','C','D','a','t','a','S','o','u','r','c','e',0 };
5070
5071     rc = MSI_DatabaseOpenViewW(package->db, driver_query, &view);
5072     if (rc != ERROR_SUCCESS)
5073         return ERROR_SUCCESS;
5074
5075     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDriver, package);
5076     msiobj_release(&view->hdr);
5077
5078     rc = MSI_DatabaseOpenViewW(package->db, translator_query, &view);
5079     if (rc != ERROR_SUCCESS)
5080         return ERROR_SUCCESS;
5081
5082     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCTranslator, package);
5083     msiobj_release(&view->hdr);
5084
5085     rc = MSI_DatabaseOpenViewW(package->db, source_query, &view);
5086     if (rc != ERROR_SUCCESS)
5087         return ERROR_SUCCESS;
5088
5089     rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDataSource, package);
5090     msiobj_release(&view->hdr);
5091
5092     return rc;
5093 }
5094
5095 #define ENV_ACT_SETALWAYS   0x1
5096 #define ENV_ACT_SETABSENT   0x2
5097 #define ENV_ACT_REMOVE      0x4
5098 #define ENV_ACT_REMOVEMATCH 0x8
5099
5100 #define ENV_MOD_MACHINE     0x20000000
5101 #define ENV_MOD_APPEND      0x40000000
5102 #define ENV_MOD_PREFIX      0x80000000
5103 #define ENV_MOD_MASK        0xC0000000
5104
5105 #define check_flag_combo(x, y) ((x) & ~(y)) == (y)
5106
5107 static LONG env_set_flags( LPCWSTR *name, LPCWSTR *value, DWORD *flags )
5108 {
5109     LPCWSTR cptr = *name;
5110     LPCWSTR ptr = *value;
5111
5112     static const WCHAR prefix[] = {'[','~',']',0};
5113     static const int prefix_len = 3;
5114
5115     *flags = 0;
5116     while (*cptr)
5117     {
5118         if (*cptr == '=')
5119             *flags |= ENV_ACT_SETALWAYS;
5120         else if (*cptr == '+')
5121             *flags |= ENV_ACT_SETABSENT;
5122         else if (*cptr == '-')
5123             *flags |= ENV_ACT_REMOVE;
5124         else if (*cptr == '!')
5125             *flags |= ENV_ACT_REMOVEMATCH;
5126         else if (*cptr == '*')
5127             *flags |= ENV_MOD_MACHINE;
5128         else
5129             break;
5130
5131         cptr++;
5132         (*name)++;
5133     }
5134
5135     if (!*cptr)
5136     {
5137         ERR("Missing environment variable\n");
5138         return ERROR_FUNCTION_FAILED;
5139     }
5140
5141     if (!strncmpW(ptr, prefix, prefix_len))
5142     {
5143         *flags |= ENV_MOD_APPEND;
5144         *value += lstrlenW(prefix);
5145     }
5146     else if (lstrlenW(*value) >= prefix_len)
5147     {
5148         ptr += lstrlenW(ptr) - prefix_len;
5149         if (!lstrcmpW(ptr, prefix))
5150         {
5151             *flags |= ENV_MOD_PREFIX;
5152             /* the "[~]" will be removed by deformat_string */;
5153         }
5154     }
5155
5156     if (!*flags ||
5157         check_flag_combo(*flags, ENV_ACT_SETALWAYS | ENV_ACT_SETABSENT) ||
5158         check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETABSENT) ||
5159         check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETALWAYS) ||
5160         check_flag_combo(*flags, ENV_ACT_SETABSENT | ENV_MOD_MASK))
5161     {
5162         ERR("Invalid flags: %08x\n", *flags);
5163         return ERROR_FUNCTION_FAILED;
5164     }
5165
5166     return ERROR_SUCCESS;
5167 }
5168
5169 static UINT ITERATE_WriteEnvironmentString( MSIRECORD *rec, LPVOID param )
5170 {
5171     MSIPACKAGE *package = param;
5172     LPCWSTR name, value;
5173     LPWSTR data = NULL, newval = NULL;
5174     LPWSTR deformatted = NULL, ptr;
5175     DWORD flags, type, size;
5176     LONG res;
5177     HKEY env = NULL, root;
5178     LPCWSTR environment;
5179
5180     static const WCHAR user_env[] =
5181         {'E','n','v','i','r','o','n','m','e','n','t',0};
5182     static const WCHAR machine_env[] =
5183         {'S','y','s','t','e','m','\\',
5184          'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
5185          'C','o','n','t','r','o','l','\\',
5186          'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
5187          'E','n','v','i','r','o','n','m','e','n','t',0};
5188     static const WCHAR semicolon[] = {';',0};
5189
5190     name = MSI_RecordGetString(rec, 2);
5191     value = MSI_RecordGetString(rec, 3);
5192
5193     res = env_set_flags(&name, &value, &flags);
5194     if (res != ERROR_SUCCESS)
5195        goto done;
5196
5197     deformat_string(package, value, &deformatted);
5198     if (!deformatted)
5199     {
5200         res = ERROR_OUTOFMEMORY;
5201         goto done;
5202     }
5203
5204     value = deformatted;
5205
5206     if (flags & ENV_MOD_MACHINE)
5207     {
5208         environment = machine_env;
5209         root = HKEY_LOCAL_MACHINE;
5210     }
5211     else
5212     {
5213         environment = user_env;
5214         root = HKEY_CURRENT_USER;
5215     }
5216
5217     res = RegCreateKeyExW(root, environment, 0, NULL, 0,
5218                           KEY_ALL_ACCESS, NULL, &env, NULL);
5219     if (res != ERROR_SUCCESS)
5220         goto done;
5221
5222     if (flags & ENV_ACT_REMOVE)
5223         FIXME("Not removing environment variable on uninstall!\n");
5224
5225     size = 0;
5226     res = RegQueryValueExW(env, name, NULL, &type, NULL, &size);
5227     if ((res != ERROR_SUCCESS && res != ERROR_FILE_NOT_FOUND) ||
5228         (res == ERROR_SUCCESS && type != REG_SZ && type != REG_EXPAND_SZ))
5229         goto done;
5230
5231     if (res != ERROR_FILE_NOT_FOUND)
5232     {
5233         if (flags & ENV_ACT_SETABSENT)
5234         {
5235             res = ERROR_SUCCESS;
5236             goto done;
5237         }
5238
5239         data = msi_alloc(size);
5240         if (!data)
5241         {
5242             RegCloseKey(env);
5243             return ERROR_OUTOFMEMORY;
5244         }
5245
5246         res = RegQueryValueExW(env, name, NULL, &type, (LPVOID)data, &size);
5247         if (res != ERROR_SUCCESS)
5248             goto done;
5249
5250         if (flags & ENV_ACT_REMOVEMATCH && (!value || !lstrcmpW(data, value)))
5251         {
5252             res = RegDeleteKeyW(env, name);
5253             goto done;
5254         }
5255
5256         size =  (lstrlenW(value) + 1 + size) * sizeof(WCHAR);
5257         newval =  msi_alloc(size);
5258         ptr = newval;
5259         if (!newval)
5260         {
5261             res = ERROR_OUTOFMEMORY;
5262             goto done;
5263         }
5264
5265         if (!(flags & ENV_MOD_MASK))
5266             lstrcpyW(newval, value);
5267         else
5268         {
5269             if (flags & ENV_MOD_PREFIX)
5270             {
5271                 lstrcpyW(newval, value);
5272                 lstrcatW(newval, semicolon);
5273                 ptr = newval + lstrlenW(value) + 1;
5274             }
5275
5276             lstrcpyW(ptr, data);
5277
5278             if (flags & ENV_MOD_APPEND)
5279             {
5280                 lstrcatW(newval, semicolon);
5281                 lstrcatW(newval, value);
5282             }
5283         }
5284     }
5285     else
5286     {
5287         size = (lstrlenW(value) + 1) * sizeof(WCHAR);
5288         newval = msi_alloc(size);
5289         if (!newval)
5290         {
5291             res = ERROR_OUTOFMEMORY;
5292             goto done;
5293         }
5294
5295         lstrcpyW(newval, value);
5296     }
5297
5298     TRACE("setting %s to %s\n", debugstr_w(name), debugstr_w(newval));
5299     res = RegSetValueExW(env, name, 0, type, (LPVOID)newval, size);
5300
5301 done:
5302     if (env) RegCloseKey(env);
5303     msi_free(deformatted);
5304     msi_free(data);
5305     msi_free(newval);
5306     return res;
5307 }
5308
5309 static UINT ACTION_WriteEnvironmentStrings( MSIPACKAGE *package )
5310 {
5311     UINT rc;
5312     MSIQUERY * view;
5313     static const WCHAR ExecSeqQuery[] =
5314         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5315          '`','E','n','v','i','r','o','n','m','e','n','t','`',0};
5316     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5317     if (rc != ERROR_SUCCESS)
5318         return ERROR_SUCCESS;
5319
5320     rc = MSI_IterateRecords(view, NULL, ITERATE_WriteEnvironmentString, package);
5321     msiobj_release(&view->hdr);
5322
5323     return rc;
5324 }
5325
5326 #define is_dot_dir(x) ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
5327
5328 typedef struct
5329 {
5330     struct list entry;
5331     LPWSTR sourcename;
5332     LPWSTR destname;
5333     LPWSTR source;
5334     LPWSTR dest;
5335 } FILE_LIST;
5336
5337 static BOOL msi_move_file(LPCWSTR source, LPCWSTR dest, int options)
5338 {
5339     BOOL ret;
5340
5341     if (GetFileAttributesW(source) == FILE_ATTRIBUTE_DIRECTORY ||
5342         GetFileAttributesW(dest) == FILE_ATTRIBUTE_DIRECTORY)
5343     {
5344         WARN("Source or dest is directory, not moving\n");
5345         return FALSE;
5346     }
5347
5348     if (options == msidbMoveFileOptionsMove)
5349     {
5350         TRACE("moving %s -> %s\n", debugstr_w(source), debugstr_w(dest));
5351         ret = MoveFileExW(source, dest, MOVEFILE_REPLACE_EXISTING);
5352         if (!ret)
5353         {
5354             WARN("MoveFile failed: %d\n", GetLastError());
5355             return FALSE;
5356         }
5357     }
5358     else
5359     {
5360         TRACE("copying %s -> %s\n", debugstr_w(source), debugstr_w(dest));
5361         ret = CopyFileW(source, dest, FALSE);
5362         if (!ret)
5363         {
5364             WARN("CopyFile failed: %d\n", GetLastError());
5365             return FALSE;
5366         }
5367     }
5368
5369     return TRUE;
5370 }
5371
5372 static LPWSTR wildcard_to_file(LPWSTR wildcard, LPWSTR filename)
5373 {
5374     LPWSTR path, ptr;
5375     DWORD dirlen, pathlen;
5376
5377     ptr = strrchrW(wildcard, '\\');
5378     dirlen = ptr - wildcard + 1;
5379
5380     pathlen = dirlen + lstrlenW(filename) + 1;
5381     path = msi_alloc(pathlen * sizeof(WCHAR));
5382
5383     lstrcpynW(path, wildcard, dirlen + 1);
5384     lstrcatW(path, filename);
5385
5386     return path;
5387 }
5388
5389 static void free_file_entry(FILE_LIST *file)
5390 {
5391     msi_free(file->source);
5392     msi_free(file->dest);
5393     msi_free(file);
5394 }
5395
5396 static void free_list(FILE_LIST *list)
5397 {
5398     while (!list_empty(&list->entry))
5399     {
5400         FILE_LIST *file = LIST_ENTRY(list_head(&list->entry), FILE_LIST, entry);
5401
5402         list_remove(&file->entry);
5403         free_file_entry(file);
5404     }
5405 }
5406
5407 static BOOL add_wildcard(FILE_LIST *files, LPWSTR source, LPWSTR dest)
5408 {
5409     FILE_LIST *new, *file;
5410     LPWSTR ptr, filename;
5411     DWORD size;
5412
5413     new = msi_alloc_zero(sizeof(FILE_LIST));
5414     if (!new)
5415         return FALSE;
5416
5417     new->source = strdupW(source);
5418     ptr = strrchrW(dest, '\\') + 1;
5419     filename = strrchrW(new->source, '\\') + 1;
5420
5421     new->sourcename = filename;
5422
5423     if (*ptr)
5424         new->destname = ptr;
5425     else
5426         new->destname = new->sourcename;
5427
5428     size = (ptr - dest) + lstrlenW(filename) + 1;
5429     new->dest = msi_alloc(size * sizeof(WCHAR));
5430     if (!new->dest)
5431     {
5432         free_file_entry(new);
5433         return FALSE;
5434     }
5435
5436     lstrcpynW(new->dest, dest, ptr - dest + 1);
5437     lstrcatW(new->dest, filename);
5438
5439     if (list_empty(&files->entry))
5440     {
5441         list_add_head(&files->entry, &new->entry);
5442         return TRUE;
5443     }
5444
5445     LIST_FOR_EACH_ENTRY(file, &files->entry, FILE_LIST, entry)
5446     {
5447         if (lstrcmpW(source, file->source) < 0)
5448         {
5449             list_add_before(&file->entry, &new->entry);
5450             return TRUE;
5451         }
5452     }
5453
5454     list_add_after(&file->entry, &new->entry);
5455     return TRUE;
5456 }
5457
5458 static BOOL move_files_wildcard(LPWSTR source, LPWSTR dest, int options)
5459 {
5460     WIN32_FIND_DATAW wfd;
5461     HANDLE hfile;
5462     LPWSTR path;
5463     BOOL res;
5464     FILE_LIST files, *file;
5465     DWORD size;
5466
5467     hfile = FindFirstFileW(source, &wfd);
5468     if (hfile == INVALID_HANDLE_VALUE) return FALSE;
5469
5470     list_init(&files.entry);
5471
5472     for (res = TRUE; res; res = FindNextFileW(hfile, &wfd))
5473     {
5474         if (is_dot_dir(wfd.cFileName)) continue;
5475
5476         path = wildcard_to_file(source, wfd.cFileName);
5477         if (!path)
5478         {
5479             res = FALSE;
5480             goto done;
5481         }
5482
5483         add_wildcard(&files, path, dest);
5484         msi_free(path);
5485     }
5486
5487     /* no files match the wildcard */
5488     if (list_empty(&files.entry))
5489         goto done;
5490
5491     /* only the first wildcard match gets renamed to dest */
5492     file = LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
5493     size = (strrchrW(file->dest, '\\') - file->dest) + lstrlenW(file->destname) + 2;
5494     file->dest = msi_realloc(file->dest, size * sizeof(WCHAR));
5495     if (!file->dest)
5496     {
5497         res = FALSE;
5498         goto done;
5499     }
5500
5501     lstrcpyW(strrchrW(file->dest, '\\') + 1, file->destname);
5502
5503     while (!list_empty(&files.entry))
5504     {
5505         file = LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
5506
5507         msi_move_file((LPCWSTR)file->source, (LPCWSTR)file->dest, options);
5508
5509         list_remove(&file->entry);
5510         free_file_entry(file);
5511     }
5512
5513     res = TRUE;
5514
5515 done:
5516     free_list(&files);
5517     FindClose(hfile);
5518     return res;
5519 }
5520
5521 static UINT ITERATE_MoveFiles( MSIRECORD *rec, LPVOID param )
5522 {
5523     MSIPACKAGE *package = param;
5524     MSICOMPONENT *comp;
5525     LPCWSTR sourcename, destname;
5526     LPWSTR sourcedir = NULL, destdir = NULL;
5527     LPWSTR source = NULL, dest = NULL;
5528     int options;
5529     DWORD size;
5530     BOOL ret, wildcards;
5531
5532     static const WCHAR backslash[] = {'\\',0};
5533
5534     comp = get_loaded_component(package, MSI_RecordGetString(rec, 2));
5535     if (!comp || !comp->Enabled ||
5536         !(comp->Action & (INSTALLSTATE_LOCAL | INSTALLSTATE_SOURCE)))
5537     {
5538         TRACE("Component not set for install, not moving file\n");
5539         return ERROR_SUCCESS;
5540     }
5541
5542     sourcename = MSI_RecordGetString(rec, 3);
5543     destname = MSI_RecordGetString(rec, 4);
5544     options = MSI_RecordGetInteger(rec, 7);
5545
5546     sourcedir = msi_dup_property(package, MSI_RecordGetString(rec, 5));
5547     if (!sourcedir)
5548         goto done;
5549
5550     destdir = msi_dup_property(package, MSI_RecordGetString(rec, 6));
5551     if (!destdir)
5552         goto done;
5553
5554     if (!sourcename)
5555     {
5556         if (GetFileAttributesW(sourcedir) == INVALID_FILE_ATTRIBUTES)
5557             goto done;
5558
5559         source = strdupW(sourcedir);
5560         if (!source)
5561             goto done;
5562     }
5563     else
5564     {
5565         size = lstrlenW(sourcedir) + lstrlenW(sourcename) + 2;
5566         source = msi_alloc(size * sizeof(WCHAR));
5567         if (!source)
5568             goto done;
5569
5570         lstrcpyW(source, sourcedir);
5571         if (source[lstrlenW(source) - 1] != '\\')
5572             lstrcatW(source, backslash);
5573         lstrcatW(source, sourcename);
5574     }
5575
5576     wildcards = strchrW(source, '*') || strchrW(source, '?');
5577
5578     if (!destname && !wildcards)
5579     {
5580         destname = strdupW(sourcename);
5581         if (!destname)
5582             goto done;
5583     }
5584
5585     size = 0;
5586     if (destname)
5587         size = lstrlenW(destname);
5588
5589     size += lstrlenW(destdir) + 2;
5590     dest = msi_alloc(size * sizeof(WCHAR));
5591     if (!dest)
5592         goto done;
5593
5594     lstrcpyW(dest, destdir);
5595     if (dest[lstrlenW(dest) - 1] != '\\')
5596         lstrcatW(dest, backslash);
5597
5598     if (destname)
5599         lstrcatW(dest, destname);
5600
5601     if (GetFileAttributesW(destdir) == INVALID_FILE_ATTRIBUTES)
5602     {
5603         ret = CreateDirectoryW(destdir, NULL);
5604         if (!ret)
5605         {
5606             WARN("CreateDirectory failed: %d\n", GetLastError());
5607             return ERROR_SUCCESS;
5608         }
5609     }
5610
5611     if (!wildcards)
5612         msi_move_file(source, dest, options);
5613     else
5614         move_files_wildcard(source, dest, options);
5615
5616 done:
5617     msi_free(sourcedir);
5618     msi_free(destdir);
5619     msi_free(source);
5620     msi_free(dest);
5621
5622     return ERROR_SUCCESS;
5623 }
5624
5625 static UINT ACTION_MoveFiles( MSIPACKAGE *package )
5626 {
5627     UINT rc;
5628     MSIQUERY *view;
5629
5630     static const WCHAR ExecSeqQuery[] =
5631         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5632          '`','M','o','v','e','F','i','l','e','`',0};
5633
5634     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5635     if (rc != ERROR_SUCCESS)
5636         return ERROR_SUCCESS;
5637
5638     rc = MSI_IterateRecords(view, NULL, ITERATE_MoveFiles, package);
5639     msiobj_release(&view->hdr);
5640
5641     return rc;
5642 }
5643
5644 static HRESULT (WINAPI *pCreateAssemblyCache)(IAssemblyCache **ppAsmCache,
5645                                               DWORD dwReserved);
5646 static HRESULT (WINAPI *pLoadLibraryShim)(LPCWSTR szDllName, LPCWSTR szVersion,
5647                                           LPVOID pvReserved, HMODULE *phModDll);
5648
5649 static BOOL init_functionpointers(void)
5650 {
5651     HRESULT hr;
5652     HMODULE hfusion;
5653     HMODULE hmscoree;
5654
5655     static const WCHAR szFusion[] = {'f','u','s','i','o','n','.','d','l','l',0};
5656
5657     hmscoree = LoadLibraryA("mscoree.dll");
5658     if (!hmscoree)
5659     {
5660         WARN("mscoree.dll not available\n");
5661         return FALSE;
5662     }
5663
5664     pLoadLibraryShim = (void *)GetProcAddress(hmscoree, "LoadLibraryShim");
5665     if (!pLoadLibraryShim)
5666     {
5667         WARN("LoadLibraryShim not available\n");
5668         FreeLibrary(hmscoree);
5669         return FALSE;
5670     }
5671
5672     hr = pLoadLibraryShim(szFusion, NULL, NULL, &hfusion);
5673     if (FAILED(hr))
5674     {
5675         WARN("fusion.dll not available\n");
5676         FreeLibrary(hmscoree);
5677         return FALSE;
5678     }
5679
5680     pCreateAssemblyCache = (void *)GetProcAddress(hfusion, "CreateAssemblyCache");
5681
5682     FreeLibrary(hmscoree);
5683     return TRUE;
5684 }
5685
5686 static UINT install_assembly(LPWSTR path)
5687 {
5688     IAssemblyCache *cache;
5689     HRESULT hr;
5690     UINT r = ERROR_FUNCTION_FAILED;
5691
5692     if (!init_functionpointers() || !pCreateAssemblyCache)
5693         return ERROR_FUNCTION_FAILED;
5694
5695     hr = pCreateAssemblyCache(&cache, 0);
5696     if (FAILED(hr))
5697         goto done;
5698
5699     hr = IAssemblyCache_InstallAssembly(cache, 0, path, NULL);
5700     if (FAILED(hr))
5701         ERR("Failed to install assembly: %s %08x\n", debugstr_w(path), hr);
5702
5703     r = ERROR_SUCCESS;
5704
5705 done:
5706     IAssemblyCache_Release(cache);
5707     return r;
5708 }
5709
5710 static UINT ITERATE_PublishAssembly( MSIRECORD *rec, LPVOID param )
5711 {
5712     MSIPACKAGE *package = param;
5713     MSICOMPONENT *comp;
5714     MSIFEATURE *feature;
5715     MSIFILE *file;
5716     WCHAR path[MAX_PATH];
5717     LPCWSTR app;
5718     DWORD attr;
5719     UINT r;
5720
5721     comp = get_loaded_component(package, MSI_RecordGetString(rec, 1));
5722     if (!comp || !comp->Enabled ||
5723         !(comp->Action & (INSTALLSTATE_LOCAL | INSTALLSTATE_SOURCE)))
5724     {
5725         ERR("Component not set for install, not publishing assembly\n");
5726         return ERROR_SUCCESS;
5727     }
5728
5729     feature = find_feature_by_name(package, MSI_RecordGetString(rec, 2));
5730     if (feature)
5731         msi_feature_set_state(feature, INSTALLSTATE_LOCAL);
5732
5733     if (MSI_RecordGetString(rec, 3))
5734         FIXME("Manifest unhandled\n");
5735
5736     app = MSI_RecordGetString(rec, 4);
5737     if (app)
5738     {
5739         FIXME("Assembly should be privately installed\n");
5740         return ERROR_SUCCESS;
5741     }
5742
5743     attr = MSI_RecordGetInteger(rec, 5);
5744     if (attr == msidbAssemblyAttributesWin32)
5745     {
5746         FIXME("Win32 assemblies not handled\n");
5747         return ERROR_SUCCESS;
5748     }
5749
5750     /* FIXME: extract all files belonging to this component */
5751     file = msi_find_file(package, comp->KeyPath);
5752     if (!file)
5753     {
5754         ERR("File %s not found\n", debugstr_w(comp->KeyPath));
5755         return ERROR_FUNCTION_FAILED;
5756     }
5757
5758     GetTempPathW(MAX_PATH, path);
5759
5760     if (file->IsCompressed)
5761     {
5762         r = msi_extract_file(package, file, path);
5763         if (r != ERROR_SUCCESS)
5764         {
5765             ERR("Failed to extract temporary assembly\n");
5766             return r;
5767         }
5768
5769         PathAddBackslashW(path);
5770         lstrcatW(path, file->FileName);
5771     }
5772     else
5773     {
5774         PathAddBackslashW(path);
5775         lstrcatW(path, file->FileName);
5776
5777         if (!CopyFileW(file->SourcePath, path, FALSE))
5778         {
5779             ERR("Failed to copy temporary assembly: %d\n", GetLastError());
5780             return ERROR_FUNCTION_FAILED;
5781         }
5782     }
5783
5784     r = install_assembly(path);
5785     if (r != ERROR_SUCCESS)
5786         ERR("Failed to install assembly\n");
5787
5788     /* FIXME: write Installer assembly reg values */
5789
5790     return r;
5791 }
5792
5793 static UINT ACTION_MsiPublishAssemblies( MSIPACKAGE *package )
5794 {
5795     UINT rc;
5796     MSIQUERY *view;
5797
5798     static const WCHAR ExecSeqQuery[] =
5799         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
5800          '`','M','s','i','A','s','s','e','m','b','l','y','`',0};
5801
5802     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
5803     if (rc != ERROR_SUCCESS)
5804         return ERROR_SUCCESS;
5805
5806     rc = MSI_IterateRecords(view, NULL, ITERATE_PublishAssembly, package);
5807     msiobj_release(&view->hdr);
5808
5809     return rc;
5810 }
5811
5812 static UINT msi_unimplemented_action_stub( MSIPACKAGE *package,
5813                                            LPCSTR action, LPCWSTR table )
5814 {
5815     static const WCHAR query[] = {
5816         'S','E','L','E','C','T',' ','*',' ',
5817         'F','R','O','M',' ','`','%','s','`',0 };
5818     MSIQUERY *view = NULL;
5819     DWORD count = 0;
5820     UINT r;
5821
5822     r = MSI_OpenQuery( package->db, &view, query, table );
5823     if (r == ERROR_SUCCESS)
5824     {
5825         r = MSI_IterateRecords(view, &count, NULL, package);
5826         msiobj_release(&view->hdr);
5827     }
5828
5829     if (count)
5830         FIXME("%s -> %u ignored %s table values\n",
5831               action, count, debugstr_w(table));
5832
5833     return ERROR_SUCCESS;
5834 }
5835
5836 static UINT ACTION_AllocateRegistrySpace( MSIPACKAGE *package )
5837 {
5838     TRACE("%p\n", package);
5839     return ERROR_SUCCESS;
5840 }
5841
5842 static UINT ACTION_RemoveIniValues( MSIPACKAGE *package )
5843 {
5844     static const WCHAR table[] =
5845          {'R','e','m','o','v','e','I','n','i','F','i','l','e',0 };
5846     return msi_unimplemented_action_stub( package, "RemoveIniValues", table );
5847 }
5848
5849 static UINT ACTION_PatchFiles( MSIPACKAGE *package )
5850 {
5851     static const WCHAR table[] = { 'P','a','t','c','h',0 };
5852     return msi_unimplemented_action_stub( package, "PatchFiles", table );
5853 }
5854
5855 static UINT ACTION_BindImage( MSIPACKAGE *package )
5856 {
5857     static const WCHAR table[] = { 'B','i','n','d','I','m','a','g','e',0 };
5858     return msi_unimplemented_action_stub( package, "BindImage", table );
5859 }
5860
5861 static UINT ACTION_IsolateComponents( MSIPACKAGE *package )
5862 {
5863     static const WCHAR table[] = {
5864         'I','s','o','l','a','t','e','C','o','m','p','o','n','e','n','t',0 };
5865     return msi_unimplemented_action_stub( package, "IsolateComponents", table );
5866 }
5867
5868 static UINT ACTION_MigrateFeatureStates( MSIPACKAGE *package )
5869 {
5870     static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
5871     return msi_unimplemented_action_stub( package, "MigrateFeatureStates", table );
5872 }
5873
5874 static UINT ACTION_SelfUnregModules( MSIPACKAGE *package )
5875 {
5876     static const WCHAR table[] = { 'S','e','l','f','R','e','g',0 };
5877     return msi_unimplemented_action_stub( package, "SelfUnregModules", table );
5878 }
5879
5880 static UINT ACTION_DeleteServices( MSIPACKAGE *package )
5881 {
5882     static const WCHAR table[] = {
5883         'S','e','r','v','i','c','e','C','o','n','t','r','o','l',0 };
5884     return msi_unimplemented_action_stub( package, "DeleteServices", table );
5885 }
5886 static UINT ACTION_ValidateProductID( MSIPACKAGE *package )
5887 {
5888         static const WCHAR table[] = {
5889                 'P','r','o','d','u','c','t','I','D',0 };
5890         return msi_unimplemented_action_stub( package, "ValidateProductID", table );
5891 }
5892
5893 static UINT ACTION_RemoveEnvironmentStrings( MSIPACKAGE *package )
5894 {
5895     static const WCHAR table[] = {
5896         'E','n','v','i','r','o','n','m','e','n','t',0 };
5897     return msi_unimplemented_action_stub( package, "RemoveEnvironmentStrings", table );
5898 }
5899
5900 static UINT ACTION_MsiUnpublishAssemblies( MSIPACKAGE *package )
5901 {
5902     static const WCHAR table[] = {
5903         'M','s','i','A','s','s','e','m','b','l','y',0 };
5904     return msi_unimplemented_action_stub( package, "MsiUnpublishAssemblies", table );
5905 }
5906
5907 static UINT ACTION_UnregisterFonts( MSIPACKAGE *package )
5908 {
5909     static const WCHAR table[] = { 'F','o','n','t',0 };
5910     return msi_unimplemented_action_stub( package, "UnregisterFonts", table );
5911 }
5912
5913 static UINT ACTION_RMCCPSearch( MSIPACKAGE *package )
5914 {
5915     static const WCHAR table[] = { 'C','C','P','S','e','a','r','c','h',0 };
5916     return msi_unimplemented_action_stub( package, "RMCCPSearch", table );
5917 }
5918
5919 static UINT ACTION_RegisterComPlus( MSIPACKAGE *package )
5920 {
5921     static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
5922     return msi_unimplemented_action_stub( package, "RegisterComPlus", table );
5923 }
5924
5925 static UINT ACTION_UnregisterComPlus( MSIPACKAGE *package )
5926 {
5927     static const WCHAR table[] = { 'C','o','m','p','l','u','s',0 };
5928     return msi_unimplemented_action_stub( package, "UnregisterComPlus", table );
5929 }
5930
5931 static UINT ACTION_InstallSFPCatalogFile( MSIPACKAGE *package )
5932 {
5933     static const WCHAR table[] = { 'S','F','P','C','a','t','a','l','o','g',0 };
5934     return msi_unimplemented_action_stub( package, "InstallSFPCatalogFile", table );
5935 }
5936
5937 static UINT ACTION_RemoveDuplicateFiles( MSIPACKAGE *package )
5938 {
5939     static const WCHAR table[] = { 'D','u','p','l','i','c','a','t','e','F','i','l','e',0 };
5940     return msi_unimplemented_action_stub( package, "RemoveDuplicateFiles", table );
5941 }
5942
5943 static UINT ACTION_RemoveExistingProducts( MSIPACKAGE *package )
5944 {
5945     static const WCHAR table[] = { 'U','p','g','r','a','d','e',0 };
5946     return msi_unimplemented_action_stub( package, "RemoveExistingProducts", table );
5947 }
5948
5949 static UINT ACTION_RemoveFolders( MSIPACKAGE *package )
5950 {
5951     static const WCHAR table[] = { 'C','r','e','a','t','e','F','o','l','d','e','r',0 };
5952     return msi_unimplemented_action_stub( package, "RemoveFolders", table );
5953 }
5954
5955 static UINT ACTION_RemoveODBC( MSIPACKAGE *package )
5956 {
5957     static const WCHAR table[] = { 'O','D','B','C','D','r','i','v','e','r',0 };
5958     return msi_unimplemented_action_stub( package, "RemoveODBC", table );
5959 }
5960
5961 static UINT ACTION_RemoveRegistryValues( MSIPACKAGE *package )
5962 {
5963     static const WCHAR table[] = { 'R','e','m','o','v','e','R','e','g','i','s','t','r','y',0 };
5964     return msi_unimplemented_action_stub( package, "RemoveRegistryValues", table );
5965 }
5966
5967 static UINT ACTION_RemoveShortcuts( MSIPACKAGE *package )
5968 {
5969     static const WCHAR table[] = { 'S','h','o','r','t','c','u','t',0 };
5970     return msi_unimplemented_action_stub( package, "RemoveShortcuts", table );
5971 }
5972
5973 static UINT ACTION_UnpublishComponents( MSIPACKAGE *package )
5974 {
5975     static const WCHAR table[] = { 'P','u','b','l','i','s','h','C','o','m','p','o','n','e','n','t',0 };
5976     return msi_unimplemented_action_stub( package, "UnpublishComponents", table );
5977 }
5978
5979 static UINT ACTION_UnregisterClassInfo( MSIPACKAGE *package )
5980 {
5981     static const WCHAR table[] = { 'A','p','p','I','d',0 };
5982     return msi_unimplemented_action_stub( package, "UnregisterClassInfo", table );
5983 }
5984
5985 static UINT ACTION_UnregisterExtensionInfo( MSIPACKAGE *package )
5986 {
5987     static const WCHAR table[] = { 'E','x','t','e','n','s','i','o','n',0 };
5988     return msi_unimplemented_action_stub( package, "UnregisterExtensionInfo", table );
5989 }
5990
5991 static UINT ACTION_UnregisterMIMEInfo( MSIPACKAGE *package )
5992 {
5993     static const WCHAR table[] = { 'M','I','M','E',0 };
5994     return msi_unimplemented_action_stub( package, "UnregisterMIMEInfo", table );
5995 }
5996
5997 static UINT ACTION_UnregisterProgIdInfo( MSIPACKAGE *package )
5998 {
5999     static const WCHAR table[] = { 'P','r','o','g','I','d',0 };
6000     return msi_unimplemented_action_stub( package, "UnregisterProgIdInfo", table );
6001 }
6002
6003 static UINT ACTION_UnregisterTypeLibraries( MSIPACKAGE *package )
6004 {
6005     static const WCHAR table[] = { 'T','y','p','e','L','i','b',0 };
6006     return msi_unimplemented_action_stub( package, "UnregisterTypeLibraries", table );
6007 }
6008
6009 static const struct _actions StandardActions[] = {
6010     { szAllocateRegistrySpace, ACTION_AllocateRegistrySpace },
6011     { szAppSearch, ACTION_AppSearch },
6012     { szBindImage, ACTION_BindImage },
6013     { szCCPSearch, ACTION_CCPSearch },
6014     { szCostFinalize, ACTION_CostFinalize },
6015     { szCostInitialize, ACTION_CostInitialize },
6016     { szCreateFolders, ACTION_CreateFolders },
6017     { szCreateShortcuts, ACTION_CreateShortcuts },
6018     { szDeleteServices, ACTION_DeleteServices },
6019     { szDisableRollback, NULL },
6020     { szDuplicateFiles, ACTION_DuplicateFiles },
6021     { szExecuteAction, ACTION_ExecuteAction },
6022     { szFileCost, ACTION_FileCost },
6023     { szFindRelatedProducts, ACTION_FindRelatedProducts },
6024     { szForceReboot, ACTION_ForceReboot },
6025     { szInstallAdminPackage, NULL },
6026     { szInstallExecute, ACTION_InstallExecute },
6027     { szInstallExecuteAgain, ACTION_InstallExecute },
6028     { szInstallFiles, ACTION_InstallFiles},
6029     { szInstallFinalize, ACTION_InstallFinalize },
6030     { szInstallInitialize, ACTION_InstallInitialize },
6031     { szInstallSFPCatalogFile, ACTION_InstallSFPCatalogFile },
6032     { szInstallValidate, ACTION_InstallValidate },
6033     { szIsolateComponents, ACTION_IsolateComponents },
6034     { szLaunchConditions, ACTION_LaunchConditions },
6035     { szMigrateFeatureStates, ACTION_MigrateFeatureStates },
6036     { szMoveFiles, ACTION_MoveFiles },
6037     { szMsiPublishAssemblies, ACTION_MsiPublishAssemblies },
6038     { szMsiUnpublishAssemblies, ACTION_MsiUnpublishAssemblies },
6039     { szInstallODBC, ACTION_InstallODBC },
6040     { szInstallServices, ACTION_InstallServices },
6041     { szPatchFiles, ACTION_PatchFiles },
6042     { szProcessComponents, ACTION_ProcessComponents },
6043     { szPublishComponents, ACTION_PublishComponents },
6044     { szPublishFeatures, ACTION_PublishFeatures },
6045     { szPublishProduct, ACTION_PublishProduct },
6046     { szRegisterClassInfo, ACTION_RegisterClassInfo },
6047     { szRegisterComPlus, ACTION_RegisterComPlus},
6048     { szRegisterExtensionInfo, ACTION_RegisterExtensionInfo },
6049     { szRegisterFonts, ACTION_RegisterFonts },
6050     { szRegisterMIMEInfo, ACTION_RegisterMIMEInfo },
6051     { szRegisterProduct, ACTION_RegisterProduct },
6052     { szRegisterProgIdInfo, ACTION_RegisterProgIdInfo },
6053     { szRegisterTypeLibraries, ACTION_RegisterTypeLibraries },
6054     { szRegisterUser, ACTION_RegisterUser },
6055     { szRemoveDuplicateFiles, ACTION_RemoveDuplicateFiles },
6056     { szRemoveEnvironmentStrings, ACTION_RemoveEnvironmentStrings },
6057     { szRemoveExistingProducts, ACTION_RemoveExistingProducts },
6058     { szRemoveFiles, ACTION_RemoveFiles },
6059     { szRemoveFolders, ACTION_RemoveFolders },
6060     { szRemoveIniValues, ACTION_RemoveIniValues },
6061     { szRemoveODBC, ACTION_RemoveODBC },
6062     { szRemoveRegistryValues, ACTION_RemoveRegistryValues },
6063     { szRemoveShortcuts, ACTION_RemoveShortcuts },
6064     { szResolveSource, ACTION_ResolveSource },
6065     { szRMCCPSearch, ACTION_RMCCPSearch },
6066     { szScheduleReboot, NULL },
6067     { szSelfRegModules, ACTION_SelfRegModules },
6068     { szSelfUnregModules, ACTION_SelfUnregModules },
6069     { szSetODBCFolders, NULL },
6070     { szStartServices, ACTION_StartServices },
6071     { szStopServices, ACTION_StopServices },
6072     { szUnpublishComponents, ACTION_UnpublishComponents },
6073     { szUnpublishFeatures, ACTION_UnpublishFeatures },
6074     { szUnregisterClassInfo, ACTION_UnregisterClassInfo },
6075     { szUnregisterComPlus, ACTION_UnregisterComPlus },
6076     { szUnregisterExtensionInfo, ACTION_UnregisterExtensionInfo },
6077     { szUnregisterFonts, ACTION_UnregisterFonts },
6078     { szUnregisterMIMEInfo, ACTION_UnregisterMIMEInfo },
6079     { szUnregisterProgIdInfo, ACTION_UnregisterProgIdInfo },
6080     { szUnregisterTypeLibraries, ACTION_UnregisterTypeLibraries },
6081     { szValidateProductID, ACTION_ValidateProductID },
6082     { szWriteEnvironmentStrings, ACTION_WriteEnvironmentStrings },
6083     { szWriteIniValues, ACTION_WriteIniValues },
6084     { szWriteRegistryValues, ACTION_WriteRegistryValues },
6085     { NULL, NULL },
6086 };
6087
6088 static BOOL ACTION_HandleStandardAction(MSIPACKAGE *package, LPCWSTR action,
6089                                         UINT* rc, BOOL force )
6090 {
6091     BOOL ret = FALSE;
6092     BOOL run = force;
6093     int i;
6094
6095     if (!run && !package->script->CurrentlyScripting)
6096         run = TRUE;
6097
6098     if (!run)
6099     {
6100         if (strcmpW(action,szInstallFinalize) == 0 ||
6101             strcmpW(action,szInstallExecute) == 0 ||
6102             strcmpW(action,szInstallExecuteAgain) == 0)
6103                 run = TRUE;
6104     }
6105
6106     i = 0;
6107     while (StandardActions[i].action != NULL)
6108     {
6109         if (strcmpW(StandardActions[i].action, action)==0)
6110         {
6111             if (!run)
6112             {
6113                 ui_actioninfo(package, action, TRUE, 0);
6114                 *rc = schedule_action(package,INSTALL_SCRIPT,action);
6115                 ui_actioninfo(package, action, FALSE, *rc);
6116             }
6117             else
6118             {
6119                 ui_actionstart(package, action);
6120                 if (StandardActions[i].handler)
6121                 {
6122                     *rc = StandardActions[i].handler(package);
6123                 }
6124                 else
6125                 {
6126                     FIXME("unhandled standard action %s\n",debugstr_w(action));
6127                     *rc = ERROR_SUCCESS;
6128                 }
6129             }
6130             ret = TRUE;
6131             break;
6132         }
6133         i++;
6134     }
6135     return ret;
6136 }