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